diff --git a/.custom-gcl.yml b/.custom-gcl.yml index ecc94f367d..311dc036bd 100644 --- a/.custom-gcl.yml +++ b/.custom-gcl.yml @@ -1,6 +1,6 @@ # yaml-language-server: $schema=https://golangci-lint.run/jsonschema/custom-gcl.jsonschema.json -version: v2.4.0 +version: v2.5.0 destination: ./_tools diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml index 35712d3de8..21ba9905a5 100644 --- a/.github/workflows/codeql.yml +++ b/.github/workflows/codeql.yml @@ -48,7 +48,7 @@ jobs: # Initializes the CodeQL tools for scanning. - name: Initialize CodeQL - uses: github/codeql-action/init@3599b3baa15b485a2e49ef411a7a4bb2452e7f93 # v3.29.5 + uses: github/codeql-action/init@64d10c13136e1c5bce3e5fbde8d4906eeaafc885 # v3.29.5 with: config-file: ./.github/codeql/codeql-configuration.yml # Override language selection by uncommenting this and choosing your languages @@ -58,7 +58,7 @@ jobs: # Autobuild attempts to build any compiled languages (C/C++, C#, or Java). # If this step fails, then you should remove it and run the build manually (see below). - name: Autobuild - uses: github/codeql-action/autobuild@3599b3baa15b485a2e49ef411a7a4bb2452e7f93 # v3.29.5 + uses: github/codeql-action/autobuild@64d10c13136e1c5bce3e5fbde8d4906eeaafc885 # v3.29.5 # ℹī¸ Command-line programs to run using the OS shell. # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun @@ -72,4 +72,4 @@ jobs: # make release - name: Perform CodeQL Analysis - uses: github/codeql-action/analyze@3599b3baa15b485a2e49ef411a7a4bb2452e7f93 # v3.29.5 + uses: github/codeql-action/analyze@64d10c13136e1c5bce3e5fbde8d4906eeaafc885 # v3.29.5 diff --git a/.github/workflows/create-cache.yml b/.github/workflows/create-cache.yml index df7cf27b7d..618f19422e 100644 --- a/.github/workflows/create-cache.yml +++ b/.github/workflows/create-cache.yml @@ -1,48 +1,48 @@ -name: Create CI cache - -on: - workflow_dispatch: - push: - branches: - - main - schedule: - # Run every day at 10:00 UTC / 03:00 PST - - cron: '0 10 * * *' - -permissions: - contents: read - -# Ensure scripts are run with pipefail. See: -# https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#exit-codes-and-error-action-preference -defaults: - run: - shell: bash - -jobs: - cache: - strategy: - fail-fast: false - matrix: - os: - - ubuntu-latest - - windows-latest - - macos-latest - go-version: - - '>=1.25.0' - - runs-on: ${{ matrix.os }} - - steps: - - run: git config --system core.longpaths true - if: ${{ matrix.os == 'windows-latest' }} - - - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 - with: - submodules: true - - uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5.0.0 - - uses: dtolnay/rust-toolchain@fcf085fcb4b4b8f63f96906cd713eb52181b5ea4 # stable - - - uses: ./.github/actions/setup-go - with: - go-version: ${{ matrix.go-version }} - create: 'true' +# name: Create CI cache + +# on: +# workflow_dispatch: +# push: +# branches: +# - main +# schedule: +# # Run every day at 10:00 UTC / 03:00 PST +# - cron: '0 10 * * *' + +# permissions: +# contents: read + +# # Ensure scripts are run with pipefail. See: +# # https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#exit-codes-and-error-action-preference +# defaults: +# run: +# shell: bash + +# jobs: +# cache: +# strategy: +# fail-fast: false +# matrix: +# os: +# - ubuntu-latest +# - windows-latest +# - macos-latest +# go-version: +# - '>=1.25.0' + +# runs-on: ${{ matrix.os }} + +# steps: +# - run: git config --system core.longpaths true +# if: ${{ matrix.os == 'windows-latest' }} + +# - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 +# with: +# submodules: true +# - uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5.0.0 +# - uses: dtolnay/rust-toolchain@fcf085fcb4b4b8f63f96906cd713eb52181b5ea4 # stable + +# - uses: ./.github/actions/setup-go +# with: +# go-version: ${{ matrix.go-version }} +# create: 'true' diff --git a/NOTICE.txt b/NOTICE.txt index c5bab5281f..68395c04eb 100644 --- a/NOTICE.txt +++ b/NOTICE.txt @@ -221,7 +221,7 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND --------------------------------------------------------- -github.com/go-json-experiment/json v0.0.0-20250813233538-9b1f9ea2e11b - BSD-3-Clause +github.com/go-json-experiment/json v0.0.0-20250910080747-cc2cfa0554c3 - BSD-3-Clause Copyright 2010 The Go Authors diff --git a/_extension/package.json b/_extension/package.json index 8aca1f4c3d..6fd7113d63 100644 --- a/_extension/package.json +++ b/_extension/package.json @@ -106,7 +106,7 @@ }, "devDependencies": { "@types/vscode": "^1.100.0", - "@vscode/vsce": "^3.6.0", - "esbuild": "^0.25.8" + "@vscode/vsce": "^3.6.2", + "esbuild": "^0.25.10" } } diff --git a/_packages/api/src/node.ts b/_packages/api/src/node.ts index 9c757e9d9b..3145e84ae8 100644 --- a/_packages/api/src/node.ts +++ b/_packages/api/src/node.ts @@ -544,7 +544,6 @@ export class RemoteNode extends RemoteNodeBase implements Node { get isTypeOnly(): boolean | undefined { switch (this.kind) { case SyntaxKind.ImportSpecifier: - case SyntaxKind.ImportClause: case SyntaxKind.ExportSpecifier: case SyntaxKind.ImportEqualsDeclaration: case SyntaxKind.ExportDeclaration: @@ -921,6 +920,18 @@ export class RemoteNode extends RemoteNodeBase implements Node { } } + get phaseModifier(): SyntaxKind { + switch (this.kind) { + case SyntaxKind.ImportClause: + const flags = (this.data & (1 << 24 | 1 << 25)) >> 24; + if (flags & 1) return SyntaxKind.TypeKeyword; + if (flags & 2) return SyntaxKind.DeferKeyword; + // fallthrough + default: + return SyntaxKind.Unknown; + } + } + get token(): SyntaxKind | undefined { switch (this.kind) { case SyntaxKind.ImportAttributes: diff --git a/_packages/ast/src/nodes.ts b/_packages/ast/src/nodes.ts index 2798419285..dcd68f6b21 100644 --- a/_packages/ast/src/nodes.ts +++ b/_packages/ast/src/nodes.ts @@ -1992,11 +1992,16 @@ export type NamedExportBindings = export interface ImportClause extends NamedDeclaration { readonly kind: SyntaxKind.ImportClause; readonly parent: ImportDeclaration | JSDocImportTag; - readonly isTypeOnly: boolean; + readonly phaseModifier: ImportPhaseModifierSyntaxKind; readonly name?: Identifier; // Default binding readonly namedBindings?: NamedImportBindings; } +export type ImportPhaseModifierSyntaxKind = + | SyntaxKind.Unknown + | SyntaxKind.TypeKeyword + | SyntaxKind.DeferKeyword; + /** @deprecated */ export type AssertionKey = ImportAttributeName; diff --git a/_packages/ast/src/syntaxKind.enum.ts b/_packages/ast/src/syntaxKind.enum.ts index 71dea4aeea..946392e4e6 100644 --- a/_packages/ast/src/syntaxKind.enum.ts +++ b/_packages/ast/src/syntaxKind.enum.ts @@ -165,6 +165,7 @@ export enum SyntaxKind { BigIntKeyword, OverrideKeyword, OfKeyword, + DeferKeyword, QualifiedName, ComputedPropertyName, TypeParameter, diff --git a/_packages/ast/src/syntaxKind.ts b/_packages/ast/src/syntaxKind.ts index a4ea40b129..b63da53dbc 100644 --- a/_packages/ast/src/syntaxKind.ts +++ b/_packages/ast/src/syntaxKind.ts @@ -168,192 +168,193 @@ export var SyntaxKind: any; SyntaxKind[SyntaxKind["BigIntKeyword"] = 163] = "BigIntKeyword"; SyntaxKind[SyntaxKind["OverrideKeyword"] = 164] = "OverrideKeyword"; SyntaxKind[SyntaxKind["OfKeyword"] = 165] = "OfKeyword"; - SyntaxKind[SyntaxKind["QualifiedName"] = 166] = "QualifiedName"; - SyntaxKind[SyntaxKind["ComputedPropertyName"] = 167] = "ComputedPropertyName"; - SyntaxKind[SyntaxKind["TypeParameter"] = 168] = "TypeParameter"; - SyntaxKind[SyntaxKind["Parameter"] = 169] = "Parameter"; - SyntaxKind[SyntaxKind["Decorator"] = 170] = "Decorator"; - SyntaxKind[SyntaxKind["PropertySignature"] = 171] = "PropertySignature"; - SyntaxKind[SyntaxKind["PropertyDeclaration"] = 172] = "PropertyDeclaration"; - SyntaxKind[SyntaxKind["MethodSignature"] = 173] = "MethodSignature"; - SyntaxKind[SyntaxKind["MethodDeclaration"] = 174] = "MethodDeclaration"; - SyntaxKind[SyntaxKind["ClassStaticBlockDeclaration"] = 175] = "ClassStaticBlockDeclaration"; - SyntaxKind[SyntaxKind["Constructor"] = 176] = "Constructor"; - SyntaxKind[SyntaxKind["GetAccessor"] = 177] = "GetAccessor"; - SyntaxKind[SyntaxKind["SetAccessor"] = 178] = "SetAccessor"; - SyntaxKind[SyntaxKind["CallSignature"] = 179] = "CallSignature"; - SyntaxKind[SyntaxKind["ConstructSignature"] = 180] = "ConstructSignature"; - SyntaxKind[SyntaxKind["IndexSignature"] = 181] = "IndexSignature"; - SyntaxKind[SyntaxKind["TypePredicate"] = 182] = "TypePredicate"; - SyntaxKind[SyntaxKind["TypeReference"] = 183] = "TypeReference"; - SyntaxKind[SyntaxKind["FunctionType"] = 184] = "FunctionType"; - SyntaxKind[SyntaxKind["ConstructorType"] = 185] = "ConstructorType"; - SyntaxKind[SyntaxKind["TypeQuery"] = 186] = "TypeQuery"; - SyntaxKind[SyntaxKind["TypeLiteral"] = 187] = "TypeLiteral"; - SyntaxKind[SyntaxKind["ArrayType"] = 188] = "ArrayType"; - SyntaxKind[SyntaxKind["TupleType"] = 189] = "TupleType"; - SyntaxKind[SyntaxKind["OptionalType"] = 190] = "OptionalType"; - SyntaxKind[SyntaxKind["RestType"] = 191] = "RestType"; - SyntaxKind[SyntaxKind["UnionType"] = 192] = "UnionType"; - SyntaxKind[SyntaxKind["IntersectionType"] = 193] = "IntersectionType"; - SyntaxKind[SyntaxKind["ConditionalType"] = 194] = "ConditionalType"; - SyntaxKind[SyntaxKind["InferType"] = 195] = "InferType"; - SyntaxKind[SyntaxKind["ParenthesizedType"] = 196] = "ParenthesizedType"; - SyntaxKind[SyntaxKind["ThisType"] = 197] = "ThisType"; - SyntaxKind[SyntaxKind["TypeOperator"] = 198] = "TypeOperator"; - SyntaxKind[SyntaxKind["IndexedAccessType"] = 199] = "IndexedAccessType"; - SyntaxKind[SyntaxKind["MappedType"] = 200] = "MappedType"; - SyntaxKind[SyntaxKind["LiteralType"] = 201] = "LiteralType"; - SyntaxKind[SyntaxKind["NamedTupleMember"] = 202] = "NamedTupleMember"; - SyntaxKind[SyntaxKind["TemplateLiteralType"] = 203] = "TemplateLiteralType"; - SyntaxKind[SyntaxKind["TemplateLiteralTypeSpan"] = 204] = "TemplateLiteralTypeSpan"; - SyntaxKind[SyntaxKind["ImportType"] = 205] = "ImportType"; - SyntaxKind[SyntaxKind["ObjectBindingPattern"] = 206] = "ObjectBindingPattern"; - SyntaxKind[SyntaxKind["ArrayBindingPattern"] = 207] = "ArrayBindingPattern"; - SyntaxKind[SyntaxKind["BindingElement"] = 208] = "BindingElement"; - SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 209] = "ArrayLiteralExpression"; - SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 210] = "ObjectLiteralExpression"; - SyntaxKind[SyntaxKind["PropertyAccessExpression"] = 211] = "PropertyAccessExpression"; - SyntaxKind[SyntaxKind["ElementAccessExpression"] = 212] = "ElementAccessExpression"; - SyntaxKind[SyntaxKind["CallExpression"] = 213] = "CallExpression"; - SyntaxKind[SyntaxKind["NewExpression"] = 214] = "NewExpression"; - SyntaxKind[SyntaxKind["TaggedTemplateExpression"] = 215] = "TaggedTemplateExpression"; - SyntaxKind[SyntaxKind["TypeAssertionExpression"] = 216] = "TypeAssertionExpression"; - SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 217] = "ParenthesizedExpression"; - SyntaxKind[SyntaxKind["FunctionExpression"] = 218] = "FunctionExpression"; - SyntaxKind[SyntaxKind["ArrowFunction"] = 219] = "ArrowFunction"; - SyntaxKind[SyntaxKind["DeleteExpression"] = 220] = "DeleteExpression"; - SyntaxKind[SyntaxKind["TypeOfExpression"] = 221] = "TypeOfExpression"; - SyntaxKind[SyntaxKind["VoidExpression"] = 222] = "VoidExpression"; - SyntaxKind[SyntaxKind["AwaitExpression"] = 223] = "AwaitExpression"; - SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 224] = "PrefixUnaryExpression"; - SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 225] = "PostfixUnaryExpression"; - SyntaxKind[SyntaxKind["BinaryExpression"] = 226] = "BinaryExpression"; - SyntaxKind[SyntaxKind["ConditionalExpression"] = 227] = "ConditionalExpression"; - SyntaxKind[SyntaxKind["TemplateExpression"] = 228] = "TemplateExpression"; - SyntaxKind[SyntaxKind["YieldExpression"] = 229] = "YieldExpression"; - SyntaxKind[SyntaxKind["SpreadElement"] = 230] = "SpreadElement"; - SyntaxKind[SyntaxKind["ClassExpression"] = 231] = "ClassExpression"; - SyntaxKind[SyntaxKind["OmittedExpression"] = 232] = "OmittedExpression"; - SyntaxKind[SyntaxKind["ExpressionWithTypeArguments"] = 233] = "ExpressionWithTypeArguments"; - SyntaxKind[SyntaxKind["AsExpression"] = 234] = "AsExpression"; - SyntaxKind[SyntaxKind["NonNullExpression"] = 235] = "NonNullExpression"; - SyntaxKind[SyntaxKind["MetaProperty"] = 236] = "MetaProperty"; - SyntaxKind[SyntaxKind["SyntheticExpression"] = 237] = "SyntheticExpression"; - SyntaxKind[SyntaxKind["SatisfiesExpression"] = 238] = "SatisfiesExpression"; - SyntaxKind[SyntaxKind["TemplateSpan"] = 239] = "TemplateSpan"; - SyntaxKind[SyntaxKind["SemicolonClassElement"] = 240] = "SemicolonClassElement"; - SyntaxKind[SyntaxKind["Block"] = 241] = "Block"; - SyntaxKind[SyntaxKind["EmptyStatement"] = 242] = "EmptyStatement"; - SyntaxKind[SyntaxKind["VariableStatement"] = 243] = "VariableStatement"; - SyntaxKind[SyntaxKind["ExpressionStatement"] = 244] = "ExpressionStatement"; - SyntaxKind[SyntaxKind["IfStatement"] = 245] = "IfStatement"; - SyntaxKind[SyntaxKind["DoStatement"] = 246] = "DoStatement"; - SyntaxKind[SyntaxKind["WhileStatement"] = 247] = "WhileStatement"; - SyntaxKind[SyntaxKind["ForStatement"] = 248] = "ForStatement"; - SyntaxKind[SyntaxKind["ForInStatement"] = 249] = "ForInStatement"; - SyntaxKind[SyntaxKind["ForOfStatement"] = 250] = "ForOfStatement"; - SyntaxKind[SyntaxKind["ContinueStatement"] = 251] = "ContinueStatement"; - SyntaxKind[SyntaxKind["BreakStatement"] = 252] = "BreakStatement"; - SyntaxKind[SyntaxKind["ReturnStatement"] = 253] = "ReturnStatement"; - SyntaxKind[SyntaxKind["WithStatement"] = 254] = "WithStatement"; - SyntaxKind[SyntaxKind["SwitchStatement"] = 255] = "SwitchStatement"; - SyntaxKind[SyntaxKind["LabeledStatement"] = 256] = "LabeledStatement"; - SyntaxKind[SyntaxKind["ThrowStatement"] = 257] = "ThrowStatement"; - SyntaxKind[SyntaxKind["TryStatement"] = 258] = "TryStatement"; - SyntaxKind[SyntaxKind["DebuggerStatement"] = 259] = "DebuggerStatement"; - SyntaxKind[SyntaxKind["VariableDeclaration"] = 260] = "VariableDeclaration"; - SyntaxKind[SyntaxKind["VariableDeclarationList"] = 261] = "VariableDeclarationList"; - SyntaxKind[SyntaxKind["FunctionDeclaration"] = 262] = "FunctionDeclaration"; - SyntaxKind[SyntaxKind["ClassDeclaration"] = 263] = "ClassDeclaration"; - SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 264] = "InterfaceDeclaration"; - SyntaxKind[SyntaxKind["TypeAliasDeclaration"] = 265] = "TypeAliasDeclaration"; - SyntaxKind[SyntaxKind["EnumDeclaration"] = 266] = "EnumDeclaration"; - SyntaxKind[SyntaxKind["ModuleDeclaration"] = 267] = "ModuleDeclaration"; - SyntaxKind[SyntaxKind["ModuleBlock"] = 268] = "ModuleBlock"; - SyntaxKind[SyntaxKind["CaseBlock"] = 269] = "CaseBlock"; - SyntaxKind[SyntaxKind["NamespaceExportDeclaration"] = 270] = "NamespaceExportDeclaration"; - SyntaxKind[SyntaxKind["ImportEqualsDeclaration"] = 271] = "ImportEqualsDeclaration"; - SyntaxKind[SyntaxKind["ImportDeclaration"] = 272] = "ImportDeclaration"; - SyntaxKind[SyntaxKind["ImportClause"] = 273] = "ImportClause"; - SyntaxKind[SyntaxKind["NamespaceImport"] = 274] = "NamespaceImport"; - SyntaxKind[SyntaxKind["NamedImports"] = 275] = "NamedImports"; - SyntaxKind[SyntaxKind["ImportSpecifier"] = 276] = "ImportSpecifier"; - SyntaxKind[SyntaxKind["ExportAssignment"] = 277] = "ExportAssignment"; - SyntaxKind[SyntaxKind["ExportDeclaration"] = 278] = "ExportDeclaration"; - SyntaxKind[SyntaxKind["NamedExports"] = 279] = "NamedExports"; - SyntaxKind[SyntaxKind["NamespaceExport"] = 280] = "NamespaceExport"; - SyntaxKind[SyntaxKind["ExportSpecifier"] = 281] = "ExportSpecifier"; - SyntaxKind[SyntaxKind["MissingDeclaration"] = 282] = "MissingDeclaration"; - SyntaxKind[SyntaxKind["ExternalModuleReference"] = 283] = "ExternalModuleReference"; - SyntaxKind[SyntaxKind["JsxElement"] = 284] = "JsxElement"; - SyntaxKind[SyntaxKind["JsxSelfClosingElement"] = 285] = "JsxSelfClosingElement"; - SyntaxKind[SyntaxKind["JsxOpeningElement"] = 286] = "JsxOpeningElement"; - SyntaxKind[SyntaxKind["JsxClosingElement"] = 287] = "JsxClosingElement"; - SyntaxKind[SyntaxKind["JsxFragment"] = 288] = "JsxFragment"; - SyntaxKind[SyntaxKind["JsxOpeningFragment"] = 289] = "JsxOpeningFragment"; - SyntaxKind[SyntaxKind["JsxClosingFragment"] = 290] = "JsxClosingFragment"; - SyntaxKind[SyntaxKind["JsxAttribute"] = 291] = "JsxAttribute"; - SyntaxKind[SyntaxKind["JsxAttributes"] = 292] = "JsxAttributes"; - SyntaxKind[SyntaxKind["JsxSpreadAttribute"] = 293] = "JsxSpreadAttribute"; - SyntaxKind[SyntaxKind["JsxExpression"] = 294] = "JsxExpression"; - SyntaxKind[SyntaxKind["JsxNamespacedName"] = 295] = "JsxNamespacedName"; - SyntaxKind[SyntaxKind["CaseClause"] = 296] = "CaseClause"; - SyntaxKind[SyntaxKind["DefaultClause"] = 297] = "DefaultClause"; - SyntaxKind[SyntaxKind["HeritageClause"] = 298] = "HeritageClause"; - SyntaxKind[SyntaxKind["CatchClause"] = 299] = "CatchClause"; - SyntaxKind[SyntaxKind["ImportAttributes"] = 300] = "ImportAttributes"; - SyntaxKind[SyntaxKind["ImportAttribute"] = 301] = "ImportAttribute"; - SyntaxKind[SyntaxKind["PropertyAssignment"] = 302] = "PropertyAssignment"; - SyntaxKind[SyntaxKind["ShorthandPropertyAssignment"] = 303] = "ShorthandPropertyAssignment"; - SyntaxKind[SyntaxKind["SpreadAssignment"] = 304] = "SpreadAssignment"; - SyntaxKind[SyntaxKind["EnumMember"] = 305] = "EnumMember"; - SyntaxKind[SyntaxKind["SourceFile"] = 306] = "SourceFile"; - SyntaxKind[SyntaxKind["Bundle"] = 307] = "Bundle"; - SyntaxKind[SyntaxKind["JSDocTypeExpression"] = 308] = "JSDocTypeExpression"; - SyntaxKind[SyntaxKind["JSDocNameReference"] = 309] = "JSDocNameReference"; - SyntaxKind[SyntaxKind["JSDocMemberName"] = 310] = "JSDocMemberName"; - SyntaxKind[SyntaxKind["JSDocAllType"] = 311] = "JSDocAllType"; - SyntaxKind[SyntaxKind["JSDocNullableType"] = 312] = "JSDocNullableType"; - SyntaxKind[SyntaxKind["JSDocNonNullableType"] = 313] = "JSDocNonNullableType"; - SyntaxKind[SyntaxKind["JSDocOptionalType"] = 314] = "JSDocOptionalType"; - SyntaxKind[SyntaxKind["JSDocVariadicType"] = 315] = "JSDocVariadicType"; - SyntaxKind[SyntaxKind["JSDoc"] = 316] = "JSDoc"; - SyntaxKind[SyntaxKind["JSDocText"] = 317] = "JSDocText"; - SyntaxKind[SyntaxKind["JSDocTypeLiteral"] = 318] = "JSDocTypeLiteral"; - SyntaxKind[SyntaxKind["JSDocSignature"] = 319] = "JSDocSignature"; - SyntaxKind[SyntaxKind["JSDocLink"] = 320] = "JSDocLink"; - SyntaxKind[SyntaxKind["JSDocLinkCode"] = 321] = "JSDocLinkCode"; - SyntaxKind[SyntaxKind["JSDocLinkPlain"] = 322] = "JSDocLinkPlain"; - SyntaxKind[SyntaxKind["JSDocTag"] = 323] = "JSDocTag"; - SyntaxKind[SyntaxKind["JSDocAugmentsTag"] = 324] = "JSDocAugmentsTag"; - SyntaxKind[SyntaxKind["JSDocImplementsTag"] = 325] = "JSDocImplementsTag"; - SyntaxKind[SyntaxKind["JSDocDeprecatedTag"] = 326] = "JSDocDeprecatedTag"; - SyntaxKind[SyntaxKind["JSDocPublicTag"] = 327] = "JSDocPublicTag"; - SyntaxKind[SyntaxKind["JSDocPrivateTag"] = 328] = "JSDocPrivateTag"; - SyntaxKind[SyntaxKind["JSDocProtectedTag"] = 329] = "JSDocProtectedTag"; - SyntaxKind[SyntaxKind["JSDocReadonlyTag"] = 330] = "JSDocReadonlyTag"; - SyntaxKind[SyntaxKind["JSDocOverrideTag"] = 331] = "JSDocOverrideTag"; - SyntaxKind[SyntaxKind["JSDocCallbackTag"] = 332] = "JSDocCallbackTag"; - SyntaxKind[SyntaxKind["JSDocOverloadTag"] = 333] = "JSDocOverloadTag"; - SyntaxKind[SyntaxKind["JSDocParameterTag"] = 334] = "JSDocParameterTag"; - SyntaxKind[SyntaxKind["JSDocReturnTag"] = 335] = "JSDocReturnTag"; - SyntaxKind[SyntaxKind["JSDocThisTag"] = 336] = "JSDocThisTag"; - SyntaxKind[SyntaxKind["JSDocTypeTag"] = 337] = "JSDocTypeTag"; - SyntaxKind[SyntaxKind["JSDocTemplateTag"] = 338] = "JSDocTemplateTag"; - SyntaxKind[SyntaxKind["JSDocTypedefTag"] = 339] = "JSDocTypedefTag"; - SyntaxKind[SyntaxKind["JSDocSeeTag"] = 340] = "JSDocSeeTag"; - SyntaxKind[SyntaxKind["JSDocPropertyTag"] = 341] = "JSDocPropertyTag"; - SyntaxKind[SyntaxKind["JSDocSatisfiesTag"] = 342] = "JSDocSatisfiesTag"; - SyntaxKind[SyntaxKind["JSDocImportTag"] = 343] = "JSDocImportTag"; - SyntaxKind[SyntaxKind["SyntaxList"] = 344] = "SyntaxList"; - SyntaxKind[SyntaxKind["JSTypeAliasDeclaration"] = 345] = "JSTypeAliasDeclaration"; - SyntaxKind[SyntaxKind["JSExportAssignment"] = 346] = "JSExportAssignment"; - SyntaxKind[SyntaxKind["CommonJSExport"] = 347] = "CommonJSExport"; - SyntaxKind[SyntaxKind["JSImportDeclaration"] = 348] = "JSImportDeclaration"; - SyntaxKind[SyntaxKind["NotEmittedStatement"] = 349] = "NotEmittedStatement"; - SyntaxKind[SyntaxKind["PartiallyEmittedExpression"] = 350] = "PartiallyEmittedExpression"; - SyntaxKind[SyntaxKind["CommaListExpression"] = 351] = "CommaListExpression"; - SyntaxKind[SyntaxKind["SyntheticReferenceExpression"] = 352] = "SyntheticReferenceExpression"; - SyntaxKind[SyntaxKind["Count"] = 353] = "Count"; + SyntaxKind[SyntaxKind["DeferKeyword"] = 166] = "DeferKeyword"; + SyntaxKind[SyntaxKind["QualifiedName"] = 167] = "QualifiedName"; + SyntaxKind[SyntaxKind["ComputedPropertyName"] = 168] = "ComputedPropertyName"; + SyntaxKind[SyntaxKind["TypeParameter"] = 169] = "TypeParameter"; + SyntaxKind[SyntaxKind["Parameter"] = 170] = "Parameter"; + SyntaxKind[SyntaxKind["Decorator"] = 171] = "Decorator"; + SyntaxKind[SyntaxKind["PropertySignature"] = 172] = "PropertySignature"; + SyntaxKind[SyntaxKind["PropertyDeclaration"] = 173] = "PropertyDeclaration"; + SyntaxKind[SyntaxKind["MethodSignature"] = 174] = "MethodSignature"; + SyntaxKind[SyntaxKind["MethodDeclaration"] = 175] = "MethodDeclaration"; + SyntaxKind[SyntaxKind["ClassStaticBlockDeclaration"] = 176] = "ClassStaticBlockDeclaration"; + SyntaxKind[SyntaxKind["Constructor"] = 177] = "Constructor"; + SyntaxKind[SyntaxKind["GetAccessor"] = 178] = "GetAccessor"; + SyntaxKind[SyntaxKind["SetAccessor"] = 179] = "SetAccessor"; + SyntaxKind[SyntaxKind["CallSignature"] = 180] = "CallSignature"; + SyntaxKind[SyntaxKind["ConstructSignature"] = 181] = "ConstructSignature"; + SyntaxKind[SyntaxKind["IndexSignature"] = 182] = "IndexSignature"; + SyntaxKind[SyntaxKind["TypePredicate"] = 183] = "TypePredicate"; + SyntaxKind[SyntaxKind["TypeReference"] = 184] = "TypeReference"; + SyntaxKind[SyntaxKind["FunctionType"] = 185] = "FunctionType"; + SyntaxKind[SyntaxKind["ConstructorType"] = 186] = "ConstructorType"; + SyntaxKind[SyntaxKind["TypeQuery"] = 187] = "TypeQuery"; + SyntaxKind[SyntaxKind["TypeLiteral"] = 188] = "TypeLiteral"; + SyntaxKind[SyntaxKind["ArrayType"] = 189] = "ArrayType"; + SyntaxKind[SyntaxKind["TupleType"] = 190] = "TupleType"; + SyntaxKind[SyntaxKind["OptionalType"] = 191] = "OptionalType"; + SyntaxKind[SyntaxKind["RestType"] = 192] = "RestType"; + SyntaxKind[SyntaxKind["UnionType"] = 193] = "UnionType"; + SyntaxKind[SyntaxKind["IntersectionType"] = 194] = "IntersectionType"; + SyntaxKind[SyntaxKind["ConditionalType"] = 195] = "ConditionalType"; + SyntaxKind[SyntaxKind["InferType"] = 196] = "InferType"; + SyntaxKind[SyntaxKind["ParenthesizedType"] = 197] = "ParenthesizedType"; + SyntaxKind[SyntaxKind["ThisType"] = 198] = "ThisType"; + SyntaxKind[SyntaxKind["TypeOperator"] = 199] = "TypeOperator"; + SyntaxKind[SyntaxKind["IndexedAccessType"] = 200] = "IndexedAccessType"; + SyntaxKind[SyntaxKind["MappedType"] = 201] = "MappedType"; + SyntaxKind[SyntaxKind["LiteralType"] = 202] = "LiteralType"; + SyntaxKind[SyntaxKind["NamedTupleMember"] = 203] = "NamedTupleMember"; + SyntaxKind[SyntaxKind["TemplateLiteralType"] = 204] = "TemplateLiteralType"; + SyntaxKind[SyntaxKind["TemplateLiteralTypeSpan"] = 205] = "TemplateLiteralTypeSpan"; + SyntaxKind[SyntaxKind["ImportType"] = 206] = "ImportType"; + SyntaxKind[SyntaxKind["ObjectBindingPattern"] = 207] = "ObjectBindingPattern"; + SyntaxKind[SyntaxKind["ArrayBindingPattern"] = 208] = "ArrayBindingPattern"; + SyntaxKind[SyntaxKind["BindingElement"] = 209] = "BindingElement"; + SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 210] = "ArrayLiteralExpression"; + SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 211] = "ObjectLiteralExpression"; + SyntaxKind[SyntaxKind["PropertyAccessExpression"] = 212] = "PropertyAccessExpression"; + SyntaxKind[SyntaxKind["ElementAccessExpression"] = 213] = "ElementAccessExpression"; + SyntaxKind[SyntaxKind["CallExpression"] = 214] = "CallExpression"; + SyntaxKind[SyntaxKind["NewExpression"] = 215] = "NewExpression"; + SyntaxKind[SyntaxKind["TaggedTemplateExpression"] = 216] = "TaggedTemplateExpression"; + SyntaxKind[SyntaxKind["TypeAssertionExpression"] = 217] = "TypeAssertionExpression"; + SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 218] = "ParenthesizedExpression"; + SyntaxKind[SyntaxKind["FunctionExpression"] = 219] = "FunctionExpression"; + SyntaxKind[SyntaxKind["ArrowFunction"] = 220] = "ArrowFunction"; + SyntaxKind[SyntaxKind["DeleteExpression"] = 221] = "DeleteExpression"; + SyntaxKind[SyntaxKind["TypeOfExpression"] = 222] = "TypeOfExpression"; + SyntaxKind[SyntaxKind["VoidExpression"] = 223] = "VoidExpression"; + SyntaxKind[SyntaxKind["AwaitExpression"] = 224] = "AwaitExpression"; + SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 225] = "PrefixUnaryExpression"; + SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 226] = "PostfixUnaryExpression"; + SyntaxKind[SyntaxKind["BinaryExpression"] = 227] = "BinaryExpression"; + SyntaxKind[SyntaxKind["ConditionalExpression"] = 228] = "ConditionalExpression"; + SyntaxKind[SyntaxKind["TemplateExpression"] = 229] = "TemplateExpression"; + SyntaxKind[SyntaxKind["YieldExpression"] = 230] = "YieldExpression"; + SyntaxKind[SyntaxKind["SpreadElement"] = 231] = "SpreadElement"; + SyntaxKind[SyntaxKind["ClassExpression"] = 232] = "ClassExpression"; + SyntaxKind[SyntaxKind["OmittedExpression"] = 233] = "OmittedExpression"; + SyntaxKind[SyntaxKind["ExpressionWithTypeArguments"] = 234] = "ExpressionWithTypeArguments"; + SyntaxKind[SyntaxKind["AsExpression"] = 235] = "AsExpression"; + SyntaxKind[SyntaxKind["NonNullExpression"] = 236] = "NonNullExpression"; + SyntaxKind[SyntaxKind["MetaProperty"] = 237] = "MetaProperty"; + SyntaxKind[SyntaxKind["SyntheticExpression"] = 238] = "SyntheticExpression"; + SyntaxKind[SyntaxKind["SatisfiesExpression"] = 239] = "SatisfiesExpression"; + SyntaxKind[SyntaxKind["TemplateSpan"] = 240] = "TemplateSpan"; + SyntaxKind[SyntaxKind["SemicolonClassElement"] = 241] = "SemicolonClassElement"; + SyntaxKind[SyntaxKind["Block"] = 242] = "Block"; + SyntaxKind[SyntaxKind["EmptyStatement"] = 243] = "EmptyStatement"; + SyntaxKind[SyntaxKind["VariableStatement"] = 244] = "VariableStatement"; + SyntaxKind[SyntaxKind["ExpressionStatement"] = 245] = "ExpressionStatement"; + SyntaxKind[SyntaxKind["IfStatement"] = 246] = "IfStatement"; + SyntaxKind[SyntaxKind["DoStatement"] = 247] = "DoStatement"; + SyntaxKind[SyntaxKind["WhileStatement"] = 248] = "WhileStatement"; + SyntaxKind[SyntaxKind["ForStatement"] = 249] = "ForStatement"; + SyntaxKind[SyntaxKind["ForInStatement"] = 250] = "ForInStatement"; + SyntaxKind[SyntaxKind["ForOfStatement"] = 251] = "ForOfStatement"; + SyntaxKind[SyntaxKind["ContinueStatement"] = 252] = "ContinueStatement"; + SyntaxKind[SyntaxKind["BreakStatement"] = 253] = "BreakStatement"; + SyntaxKind[SyntaxKind["ReturnStatement"] = 254] = "ReturnStatement"; + SyntaxKind[SyntaxKind["WithStatement"] = 255] = "WithStatement"; + SyntaxKind[SyntaxKind["SwitchStatement"] = 256] = "SwitchStatement"; + SyntaxKind[SyntaxKind["LabeledStatement"] = 257] = "LabeledStatement"; + SyntaxKind[SyntaxKind["ThrowStatement"] = 258] = "ThrowStatement"; + SyntaxKind[SyntaxKind["TryStatement"] = 259] = "TryStatement"; + SyntaxKind[SyntaxKind["DebuggerStatement"] = 260] = "DebuggerStatement"; + SyntaxKind[SyntaxKind["VariableDeclaration"] = 261] = "VariableDeclaration"; + SyntaxKind[SyntaxKind["VariableDeclarationList"] = 262] = "VariableDeclarationList"; + SyntaxKind[SyntaxKind["FunctionDeclaration"] = 263] = "FunctionDeclaration"; + SyntaxKind[SyntaxKind["ClassDeclaration"] = 264] = "ClassDeclaration"; + SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 265] = "InterfaceDeclaration"; + SyntaxKind[SyntaxKind["TypeAliasDeclaration"] = 266] = "TypeAliasDeclaration"; + SyntaxKind[SyntaxKind["EnumDeclaration"] = 267] = "EnumDeclaration"; + SyntaxKind[SyntaxKind["ModuleDeclaration"] = 268] = "ModuleDeclaration"; + SyntaxKind[SyntaxKind["ModuleBlock"] = 269] = "ModuleBlock"; + SyntaxKind[SyntaxKind["CaseBlock"] = 270] = "CaseBlock"; + SyntaxKind[SyntaxKind["NamespaceExportDeclaration"] = 271] = "NamespaceExportDeclaration"; + SyntaxKind[SyntaxKind["ImportEqualsDeclaration"] = 272] = "ImportEqualsDeclaration"; + SyntaxKind[SyntaxKind["ImportDeclaration"] = 273] = "ImportDeclaration"; + SyntaxKind[SyntaxKind["ImportClause"] = 274] = "ImportClause"; + SyntaxKind[SyntaxKind["NamespaceImport"] = 275] = "NamespaceImport"; + SyntaxKind[SyntaxKind["NamedImports"] = 276] = "NamedImports"; + SyntaxKind[SyntaxKind["ImportSpecifier"] = 277] = "ImportSpecifier"; + SyntaxKind[SyntaxKind["ExportAssignment"] = 278] = "ExportAssignment"; + SyntaxKind[SyntaxKind["ExportDeclaration"] = 279] = "ExportDeclaration"; + SyntaxKind[SyntaxKind["NamedExports"] = 280] = "NamedExports"; + SyntaxKind[SyntaxKind["NamespaceExport"] = 281] = "NamespaceExport"; + SyntaxKind[SyntaxKind["ExportSpecifier"] = 282] = "ExportSpecifier"; + SyntaxKind[SyntaxKind["MissingDeclaration"] = 283] = "MissingDeclaration"; + SyntaxKind[SyntaxKind["ExternalModuleReference"] = 284] = "ExternalModuleReference"; + SyntaxKind[SyntaxKind["JsxElement"] = 285] = "JsxElement"; + SyntaxKind[SyntaxKind["JsxSelfClosingElement"] = 286] = "JsxSelfClosingElement"; + SyntaxKind[SyntaxKind["JsxOpeningElement"] = 287] = "JsxOpeningElement"; + SyntaxKind[SyntaxKind["JsxClosingElement"] = 288] = "JsxClosingElement"; + SyntaxKind[SyntaxKind["JsxFragment"] = 289] = "JsxFragment"; + SyntaxKind[SyntaxKind["JsxOpeningFragment"] = 290] = "JsxOpeningFragment"; + SyntaxKind[SyntaxKind["JsxClosingFragment"] = 291] = "JsxClosingFragment"; + SyntaxKind[SyntaxKind["JsxAttribute"] = 292] = "JsxAttribute"; + SyntaxKind[SyntaxKind["JsxAttributes"] = 293] = "JsxAttributes"; + SyntaxKind[SyntaxKind["JsxSpreadAttribute"] = 294] = "JsxSpreadAttribute"; + SyntaxKind[SyntaxKind["JsxExpression"] = 295] = "JsxExpression"; + SyntaxKind[SyntaxKind["JsxNamespacedName"] = 296] = "JsxNamespacedName"; + SyntaxKind[SyntaxKind["CaseClause"] = 297] = "CaseClause"; + SyntaxKind[SyntaxKind["DefaultClause"] = 298] = "DefaultClause"; + SyntaxKind[SyntaxKind["HeritageClause"] = 299] = "HeritageClause"; + SyntaxKind[SyntaxKind["CatchClause"] = 300] = "CatchClause"; + SyntaxKind[SyntaxKind["ImportAttributes"] = 301] = "ImportAttributes"; + SyntaxKind[SyntaxKind["ImportAttribute"] = 302] = "ImportAttribute"; + SyntaxKind[SyntaxKind["PropertyAssignment"] = 303] = "PropertyAssignment"; + SyntaxKind[SyntaxKind["ShorthandPropertyAssignment"] = 304] = "ShorthandPropertyAssignment"; + SyntaxKind[SyntaxKind["SpreadAssignment"] = 305] = "SpreadAssignment"; + SyntaxKind[SyntaxKind["EnumMember"] = 306] = "EnumMember"; + SyntaxKind[SyntaxKind["SourceFile"] = 307] = "SourceFile"; + SyntaxKind[SyntaxKind["Bundle"] = 308] = "Bundle"; + SyntaxKind[SyntaxKind["JSDocTypeExpression"] = 309] = "JSDocTypeExpression"; + SyntaxKind[SyntaxKind["JSDocNameReference"] = 310] = "JSDocNameReference"; + SyntaxKind[SyntaxKind["JSDocMemberName"] = 311] = "JSDocMemberName"; + SyntaxKind[SyntaxKind["JSDocAllType"] = 312] = "JSDocAllType"; + SyntaxKind[SyntaxKind["JSDocNullableType"] = 313] = "JSDocNullableType"; + SyntaxKind[SyntaxKind["JSDocNonNullableType"] = 314] = "JSDocNonNullableType"; + SyntaxKind[SyntaxKind["JSDocOptionalType"] = 315] = "JSDocOptionalType"; + SyntaxKind[SyntaxKind["JSDocVariadicType"] = 316] = "JSDocVariadicType"; + SyntaxKind[SyntaxKind["JSDoc"] = 317] = "JSDoc"; + SyntaxKind[SyntaxKind["JSDocText"] = 318] = "JSDocText"; + SyntaxKind[SyntaxKind["JSDocTypeLiteral"] = 319] = "JSDocTypeLiteral"; + SyntaxKind[SyntaxKind["JSDocSignature"] = 320] = "JSDocSignature"; + SyntaxKind[SyntaxKind["JSDocLink"] = 321] = "JSDocLink"; + SyntaxKind[SyntaxKind["JSDocLinkCode"] = 322] = "JSDocLinkCode"; + SyntaxKind[SyntaxKind["JSDocLinkPlain"] = 323] = "JSDocLinkPlain"; + SyntaxKind[SyntaxKind["JSDocTag"] = 324] = "JSDocTag"; + SyntaxKind[SyntaxKind["JSDocAugmentsTag"] = 325] = "JSDocAugmentsTag"; + SyntaxKind[SyntaxKind["JSDocImplementsTag"] = 326] = "JSDocImplementsTag"; + SyntaxKind[SyntaxKind["JSDocDeprecatedTag"] = 327] = "JSDocDeprecatedTag"; + SyntaxKind[SyntaxKind["JSDocPublicTag"] = 328] = "JSDocPublicTag"; + SyntaxKind[SyntaxKind["JSDocPrivateTag"] = 329] = "JSDocPrivateTag"; + SyntaxKind[SyntaxKind["JSDocProtectedTag"] = 330] = "JSDocProtectedTag"; + SyntaxKind[SyntaxKind["JSDocReadonlyTag"] = 331] = "JSDocReadonlyTag"; + SyntaxKind[SyntaxKind["JSDocOverrideTag"] = 332] = "JSDocOverrideTag"; + SyntaxKind[SyntaxKind["JSDocCallbackTag"] = 333] = "JSDocCallbackTag"; + SyntaxKind[SyntaxKind["JSDocOverloadTag"] = 334] = "JSDocOverloadTag"; + SyntaxKind[SyntaxKind["JSDocParameterTag"] = 335] = "JSDocParameterTag"; + SyntaxKind[SyntaxKind["JSDocReturnTag"] = 336] = "JSDocReturnTag"; + SyntaxKind[SyntaxKind["JSDocThisTag"] = 337] = "JSDocThisTag"; + SyntaxKind[SyntaxKind["JSDocTypeTag"] = 338] = "JSDocTypeTag"; + SyntaxKind[SyntaxKind["JSDocTemplateTag"] = 339] = "JSDocTemplateTag"; + SyntaxKind[SyntaxKind["JSDocTypedefTag"] = 340] = "JSDocTypedefTag"; + SyntaxKind[SyntaxKind["JSDocSeeTag"] = 341] = "JSDocSeeTag"; + SyntaxKind[SyntaxKind["JSDocPropertyTag"] = 342] = "JSDocPropertyTag"; + SyntaxKind[SyntaxKind["JSDocSatisfiesTag"] = 343] = "JSDocSatisfiesTag"; + SyntaxKind[SyntaxKind["JSDocImportTag"] = 344] = "JSDocImportTag"; + SyntaxKind[SyntaxKind["SyntaxList"] = 345] = "SyntaxList"; + SyntaxKind[SyntaxKind["JSTypeAliasDeclaration"] = 346] = "JSTypeAliasDeclaration"; + SyntaxKind[SyntaxKind["JSExportAssignment"] = 347] = "JSExportAssignment"; + SyntaxKind[SyntaxKind["CommonJSExport"] = 348] = "CommonJSExport"; + SyntaxKind[SyntaxKind["JSImportDeclaration"] = 349] = "JSImportDeclaration"; + SyntaxKind[SyntaxKind["NotEmittedStatement"] = 350] = "NotEmittedStatement"; + SyntaxKind[SyntaxKind["PartiallyEmittedExpression"] = 351] = "PartiallyEmittedExpression"; + SyntaxKind[SyntaxKind["CommaListExpression"] = 352] = "CommaListExpression"; + SyntaxKind[SyntaxKind["SyntheticReferenceExpression"] = 353] = "SyntheticReferenceExpression"; + SyntaxKind[SyntaxKind["Count"] = 354] = "Count"; })(SyntaxKind || (SyntaxKind = {})); diff --git a/_tools/go.mod b/_tools/go.mod index a594da84ae..be2523d4e5 100644 --- a/_tools/go.mod +++ b/_tools/go.mod @@ -5,11 +5,11 @@ go 1.25 require ( github.com/golangci/plugin-module-register v0.1.2 golang.org/x/mod v0.28.0 - golang.org/x/tools v0.36.0 + golang.org/x/tools v0.37.0 gotest.tools/v3 v3.5.2 ) require ( github.com/google/go-cmp v0.6.0 // indirect - golang.org/x/sync v0.16.0 // indirect + golang.org/x/sync v0.17.0 // indirect ) diff --git a/_tools/go.sum b/_tools/go.sum index fcba38e676..10687374b2 100644 --- a/_tools/go.sum +++ b/_tools/go.sum @@ -4,9 +4,9 @@ github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= golang.org/x/mod v0.28.0 h1:gQBtGhjxykdjY9YhZpSlZIsbnaE2+PgjfLWUQTnoZ1U= golang.org/x/mod v0.28.0/go.mod h1:yfB/L0NOf/kmEbXjzCPOx1iK1fRutOydrCMsqRhEBxI= -golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw= -golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= -golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg= -golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s= +golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug= +golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= +golang.org/x/tools v0.37.0 h1:DVSRzp7FwePZW356yEAChSdNcQo6Nsp+fex1SUW09lE= +golang.org/x/tools v0.37.0/go.mod h1:MBN5QPQtLMHVdvsbtarmTNukZDdgwdwlO5qGacAzF0w= gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q= gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA= diff --git a/go.mod b/go.mod index 11f51956d5..8f5243215c 100644 --- a/go.mod +++ b/go.mod @@ -4,7 +4,7 @@ go 1.25 require ( github.com/dlclark/regexp2 v1.11.5 - github.com/go-json-experiment/json v0.0.0-20250813233538-9b1f9ea2e11b + github.com/go-json-experiment/json v0.0.0-20250910080747-cc2cfa0554c3 github.com/google/go-cmp v0.7.0 github.com/peter-evans/patience v0.3.0 github.com/zeebo/xxh3 v1.0.2 diff --git a/go.sum b/go.sum index 90c9c62d6a..78724d28be 100644 --- a/go.sum +++ b/go.sum @@ -1,7 +1,7 @@ github.com/dlclark/regexp2 v1.11.5 h1:Q/sSnsKerHeCkc/jSTNq1oCm7KiVgUMZRDUoRu0JQZQ= github.com/dlclark/regexp2 v1.11.5/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= -github.com/go-json-experiment/json v0.0.0-20250813233538-9b1f9ea2e11b h1:6Q4zRHXS/YLOl9Ng1b1OOOBWMidAQZR3Gel0UKPC/KU= -github.com/go-json-experiment/json v0.0.0-20250813233538-9b1f9ea2e11b/go.mod h1:TiCD2a1pcmjd7YnhGH0f/zKNcCD06B029pHhzV23c2M= +github.com/go-json-experiment/json v0.0.0-20250910080747-cc2cfa0554c3 h1:02WINGfSX5w0Mn+F28UyRoSt9uvMhKguwWMlOAh6U/0= +github.com/go-json-experiment/json v0.0.0-20250910080747-cc2cfa0554c3/go.mod h1:uNVvRXArCGbZ508SxYYTC5v1JWoz2voff5pm25jU1Ok= github.com/go-quicktest/qt v1.101.0 h1:O1K29Txy5P2OK0dGo59b7b0LR6wKfIhttaAhHUyn7eI= github.com/go-quicktest/qt v1.101.0/go.mod h1:14Bz/f7NwaXPtdYEgzsx46kqSxVwTbzVZsDC26tQJow= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= diff --git a/internal/api/encoder/encoder.go b/internal/api/encoder/encoder.go index 009f1fb640..2c40c6cb80 100644 --- a/internal/api/encoder/encoder.go +++ b/internal/api/encoder/encoder.go @@ -714,7 +714,7 @@ func getNodeDefinedData(node *ast.Node) uint32 { return uint32(boolToByte(n.IsTypeOnly)) << 24 case ast.KindImportClause: n := node.AsImportClause() - return uint32(boolToByte(n.IsTypeOnly)) << 24 + return uint32(boolToByte(n.PhaseModifier == ast.KindTypeKeyword))<<24 | uint32(boolToByte(n.PhaseModifier == ast.KindDeferKeyword))<<25 case ast.KindExportSpecifier: n := node.AsExportSpecifier() return uint32(boolToByte(n.IsTypeOnly)) << 24 diff --git a/internal/ast/ast.go b/internal/ast/ast.go index 2c264f2a69..fb91b32bf6 100644 --- a/internal/ast/ast.go +++ b/internal/ast/ast.go @@ -318,6 +318,8 @@ func (n *Node) Text() string { return n.AsNumericLiteral().Text case KindBigIntLiteral: return n.AsBigIntLiteral().Text + case KindMetaProperty: + return n.AsMetaProperty().Name().Text() case KindNoSubstitutionTemplateLiteral: return n.AsNoSubstitutionTemplateLiteral().Text case KindTemplateHead: @@ -900,7 +902,7 @@ func (n *Node) IsTypeOnly() bool { case KindImportSpecifier: return n.AsImportSpecifier().IsTypeOnly case KindImportClause: - return n.AsImportClause().IsTypeOnly + return n.AsImportClause().PhaseModifier == KindTypeKeyword case KindExportDeclaration: return n.AsExportDeclaration().IsTypeOnly case KindExportSpecifier: @@ -4951,22 +4953,22 @@ type ImportClause struct { DeclarationBase ExportableBase compositeNodeBase - IsTypeOnly bool + PhaseModifier Kind // KindTypeKeyword | KindDeferKeyword NamedBindings *NamedImportBindings // NamedImportBindings. Optional, named bindings name *IdentifierNode // IdentifierNode. Optional, default binding } -func (f *NodeFactory) NewImportClause(isTypeOnly bool, name *IdentifierNode, namedBindings *NamedImportBindings) *Node { +func (f *NodeFactory) NewImportClause(phaseModifier Kind, name *IdentifierNode, namedBindings *NamedImportBindings) *Node { data := &ImportClause{} - data.IsTypeOnly = isTypeOnly + data.PhaseModifier = phaseModifier data.name = name data.NamedBindings = namedBindings return f.newNode(KindImportClause, data) } -func (f *NodeFactory) UpdateImportClause(node *ImportClause, isTypeOnly bool, name *IdentifierNode, namedBindings *NamedImportBindings) *Node { - if isTypeOnly != node.IsTypeOnly || name != node.name || namedBindings != node.NamedBindings { - return updateNode(f.NewImportClause(isTypeOnly, name, namedBindings), node.AsNode(), f.hooks) +func (f *NodeFactory) UpdateImportClause(node *ImportClause, phaseModifier Kind, name *IdentifierNode, namedBindings *NamedImportBindings) *Node { + if phaseModifier != node.PhaseModifier || name != node.name || namedBindings != node.NamedBindings { + return updateNode(f.NewImportClause(phaseModifier, name, namedBindings), node.AsNode(), f.hooks) } return node.AsNode() } @@ -4976,11 +4978,11 @@ func (node *ImportClause) ForEachChild(v Visitor) bool { } func (node *ImportClause) VisitEachChild(v *NodeVisitor) *Node { - return v.Factory.UpdateImportClause(node, node.IsTypeOnly, v.visitNode(node.name), v.visitNode(node.NamedBindings)) + return v.Factory.UpdateImportClause(node, node.PhaseModifier, v.visitNode(node.name), v.visitNode(node.NamedBindings)) } func (node *ImportClause) Clone(f NodeFactoryCoercible) *Node { - return cloneNode(f.AsNodeFactory().NewImportClause(node.IsTypeOnly, node.Name(), node.NamedBindings), node.AsNode(), f.AsNodeFactory().hooks) + return cloneNode(f.AsNodeFactory().NewImportClause(node.PhaseModifier, node.Name(), node.NamedBindings), node.AsNode(), f.AsNodeFactory().hooks) } func (node *ImportClause) Name() *DeclarationName { @@ -4988,7 +4990,7 @@ func (node *ImportClause) Name() *DeclarationName { } func (node *ImportClause) computeSubtreeFacts() SubtreeFacts { - if node.IsTypeOnly { + if node.PhaseModifier == KindTypeKeyword { return SubtreeContainsTypeScript } else { return propagateSubtreeFacts(node.name) | diff --git a/internal/ast/kind.go b/internal/ast/kind.go index 9f6bc22720..57cdaf6f98 100644 --- a/internal/ast/kind.go +++ b/internal/ast/kind.go @@ -180,7 +180,8 @@ const ( KindGlobalKeyword KindBigIntKeyword KindOverrideKeyword - KindOfKeyword // LastKeyword and LastToken and LastContextualKeyword + KindOfKeyword + KindDeferKeyword // LastKeyword and LastToken and LastContextualKeyword // Parse tree nodes // Names KindQualifiedName @@ -399,7 +400,7 @@ const ( KindFirstReservedWord = KindBreakKeyword KindLastReservedWord = KindWithKeyword KindFirstKeyword = KindBreakKeyword - KindLastKeyword = KindOfKeyword + KindLastKeyword = KindDeferKeyword KindFirstFutureReservedWord = KindImplementsKeyword KindLastFutureReservedWord = KindYieldKeyword KindFirstTypeNode = KindTypePredicate @@ -422,7 +423,7 @@ const ( KindFirstJSDocTagNode = KindJSDocTag KindLastJSDocTagNode = KindJSDocImportTag KindFirstContextualKeyword = KindAbstractKeyword - KindLastContextualKeyword = KindOfKeyword + KindLastContextualKeyword = KindDeferKeyword KindComment = KindSingleLineCommentTrivia | KindMultiLineCommentTrivia KindFirstTriviaToken = KindSingleLineCommentTrivia KindLastTriviaToken = KindConflictMarkerTrivia diff --git a/internal/ast/kind_stringer_generated.go b/internal/ast/kind_stringer_generated.go index ba139db8a9..ac4a204fba 100644 --- a/internal/ast/kind_stringer_generated.go +++ b/internal/ast/kind_stringer_generated.go @@ -174,200 +174,201 @@ func _() { _ = x[KindBigIntKeyword-163] _ = x[KindOverrideKeyword-164] _ = x[KindOfKeyword-165] - _ = x[KindQualifiedName-166] - _ = x[KindComputedPropertyName-167] - _ = x[KindTypeParameter-168] - _ = x[KindParameter-169] - _ = x[KindDecorator-170] - _ = x[KindPropertySignature-171] - _ = x[KindPropertyDeclaration-172] - _ = x[KindMethodSignature-173] - _ = x[KindMethodDeclaration-174] - _ = x[KindClassStaticBlockDeclaration-175] - _ = x[KindConstructor-176] - _ = x[KindGetAccessor-177] - _ = x[KindSetAccessor-178] - _ = x[KindCallSignature-179] - _ = x[KindConstructSignature-180] - _ = x[KindIndexSignature-181] - _ = x[KindTypePredicate-182] - _ = x[KindTypeReference-183] - _ = x[KindFunctionType-184] - _ = x[KindConstructorType-185] - _ = x[KindTypeQuery-186] - _ = x[KindTypeLiteral-187] - _ = x[KindArrayType-188] - _ = x[KindTupleType-189] - _ = x[KindOptionalType-190] - _ = x[KindRestType-191] - _ = x[KindUnionType-192] - _ = x[KindIntersectionType-193] - _ = x[KindConditionalType-194] - _ = x[KindInferType-195] - _ = x[KindParenthesizedType-196] - _ = x[KindThisType-197] - _ = x[KindTypeOperator-198] - _ = x[KindIndexedAccessType-199] - _ = x[KindMappedType-200] - _ = x[KindLiteralType-201] - _ = x[KindNamedTupleMember-202] - _ = x[KindTemplateLiteralType-203] - _ = x[KindTemplateLiteralTypeSpan-204] - _ = x[KindImportType-205] - _ = x[KindObjectBindingPattern-206] - _ = x[KindArrayBindingPattern-207] - _ = x[KindBindingElement-208] - _ = x[KindArrayLiteralExpression-209] - _ = x[KindObjectLiteralExpression-210] - _ = x[KindPropertyAccessExpression-211] - _ = x[KindElementAccessExpression-212] - _ = x[KindCallExpression-213] - _ = x[KindNewExpression-214] - _ = x[KindTaggedTemplateExpression-215] - _ = x[KindTypeAssertionExpression-216] - _ = x[KindParenthesizedExpression-217] - _ = x[KindFunctionExpression-218] - _ = x[KindArrowFunction-219] - _ = x[KindDeleteExpression-220] - _ = x[KindTypeOfExpression-221] - _ = x[KindVoidExpression-222] - _ = x[KindAwaitExpression-223] - _ = x[KindPrefixUnaryExpression-224] - _ = x[KindPostfixUnaryExpression-225] - _ = x[KindBinaryExpression-226] - _ = x[KindConditionalExpression-227] - _ = x[KindTemplateExpression-228] - _ = x[KindYieldExpression-229] - _ = x[KindSpreadElement-230] - _ = x[KindClassExpression-231] - _ = x[KindOmittedExpression-232] - _ = x[KindExpressionWithTypeArguments-233] - _ = x[KindAsExpression-234] - _ = x[KindNonNullExpression-235] - _ = x[KindMetaProperty-236] - _ = x[KindSyntheticExpression-237] - _ = x[KindSatisfiesExpression-238] - _ = x[KindTemplateSpan-239] - _ = x[KindSemicolonClassElement-240] - _ = x[KindBlock-241] - _ = x[KindEmptyStatement-242] - _ = x[KindVariableStatement-243] - _ = x[KindExpressionStatement-244] - _ = x[KindIfStatement-245] - _ = x[KindDoStatement-246] - _ = x[KindWhileStatement-247] - _ = x[KindForStatement-248] - _ = x[KindForInStatement-249] - _ = x[KindForOfStatement-250] - _ = x[KindContinueStatement-251] - _ = x[KindBreakStatement-252] - _ = x[KindReturnStatement-253] - _ = x[KindWithStatement-254] - _ = x[KindSwitchStatement-255] - _ = x[KindLabeledStatement-256] - _ = x[KindThrowStatement-257] - _ = x[KindTryStatement-258] - _ = x[KindDebuggerStatement-259] - _ = x[KindVariableDeclaration-260] - _ = x[KindVariableDeclarationList-261] - _ = x[KindFunctionDeclaration-262] - _ = x[KindClassDeclaration-263] - _ = x[KindInterfaceDeclaration-264] - _ = x[KindTypeAliasDeclaration-265] - _ = x[KindEnumDeclaration-266] - _ = x[KindModuleDeclaration-267] - _ = x[KindModuleBlock-268] - _ = x[KindCaseBlock-269] - _ = x[KindNamespaceExportDeclaration-270] - _ = x[KindImportEqualsDeclaration-271] - _ = x[KindImportDeclaration-272] - _ = x[KindImportClause-273] - _ = x[KindNamespaceImport-274] - _ = x[KindNamedImports-275] - _ = x[KindImportSpecifier-276] - _ = x[KindExportAssignment-277] - _ = x[KindExportDeclaration-278] - _ = x[KindNamedExports-279] - _ = x[KindNamespaceExport-280] - _ = x[KindExportSpecifier-281] - _ = x[KindMissingDeclaration-282] - _ = x[KindExternalModuleReference-283] - _ = x[KindJsxElement-284] - _ = x[KindJsxSelfClosingElement-285] - _ = x[KindJsxOpeningElement-286] - _ = x[KindJsxClosingElement-287] - _ = x[KindJsxFragment-288] - _ = x[KindJsxOpeningFragment-289] - _ = x[KindJsxClosingFragment-290] - _ = x[KindJsxAttribute-291] - _ = x[KindJsxAttributes-292] - _ = x[KindJsxSpreadAttribute-293] - _ = x[KindJsxExpression-294] - _ = x[KindJsxNamespacedName-295] - _ = x[KindCaseClause-296] - _ = x[KindDefaultClause-297] - _ = x[KindHeritageClause-298] - _ = x[KindCatchClause-299] - _ = x[KindImportAttributes-300] - _ = x[KindImportAttribute-301] - _ = x[KindPropertyAssignment-302] - _ = x[KindShorthandPropertyAssignment-303] - _ = x[KindSpreadAssignment-304] - _ = x[KindEnumMember-305] - _ = x[KindSourceFile-306] - _ = x[KindBundle-307] - _ = x[KindJSDocTypeExpression-308] - _ = x[KindJSDocNameReference-309] - _ = x[KindJSDocMemberName-310] - _ = x[KindJSDocAllType-311] - _ = x[KindJSDocNullableType-312] - _ = x[KindJSDocNonNullableType-313] - _ = x[KindJSDocOptionalType-314] - _ = x[KindJSDocVariadicType-315] - _ = x[KindJSDoc-316] - _ = x[KindJSDocText-317] - _ = x[KindJSDocTypeLiteral-318] - _ = x[KindJSDocSignature-319] - _ = x[KindJSDocLink-320] - _ = x[KindJSDocLinkCode-321] - _ = x[KindJSDocLinkPlain-322] - _ = x[KindJSDocTag-323] - _ = x[KindJSDocAugmentsTag-324] - _ = x[KindJSDocImplementsTag-325] - _ = x[KindJSDocDeprecatedTag-326] - _ = x[KindJSDocPublicTag-327] - _ = x[KindJSDocPrivateTag-328] - _ = x[KindJSDocProtectedTag-329] - _ = x[KindJSDocReadonlyTag-330] - _ = x[KindJSDocOverrideTag-331] - _ = x[KindJSDocCallbackTag-332] - _ = x[KindJSDocOverloadTag-333] - _ = x[KindJSDocParameterTag-334] - _ = x[KindJSDocReturnTag-335] - _ = x[KindJSDocThisTag-336] - _ = x[KindJSDocTypeTag-337] - _ = x[KindJSDocTemplateTag-338] - _ = x[KindJSDocTypedefTag-339] - _ = x[KindJSDocSeeTag-340] - _ = x[KindJSDocPropertyTag-341] - _ = x[KindJSDocSatisfiesTag-342] - _ = x[KindJSDocImportTag-343] - _ = x[KindSyntaxList-344] - _ = x[KindJSTypeAliasDeclaration-345] - _ = x[KindJSExportAssignment-346] - _ = x[KindCommonJSExport-347] - _ = x[KindJSImportDeclaration-348] - _ = x[KindNotEmittedStatement-349] - _ = x[KindPartiallyEmittedExpression-350] - _ = x[KindCommaListExpression-351] - _ = x[KindSyntheticReferenceExpression-352] - _ = x[KindNotEmittedTypeElement-353] - _ = x[KindCount-354] + _ = x[KindDeferKeyword-166] + _ = x[KindQualifiedName-167] + _ = x[KindComputedPropertyName-168] + _ = x[KindTypeParameter-169] + _ = x[KindParameter-170] + _ = x[KindDecorator-171] + _ = x[KindPropertySignature-172] + _ = x[KindPropertyDeclaration-173] + _ = x[KindMethodSignature-174] + _ = x[KindMethodDeclaration-175] + _ = x[KindClassStaticBlockDeclaration-176] + _ = x[KindConstructor-177] + _ = x[KindGetAccessor-178] + _ = x[KindSetAccessor-179] + _ = x[KindCallSignature-180] + _ = x[KindConstructSignature-181] + _ = x[KindIndexSignature-182] + _ = x[KindTypePredicate-183] + _ = x[KindTypeReference-184] + _ = x[KindFunctionType-185] + _ = x[KindConstructorType-186] + _ = x[KindTypeQuery-187] + _ = x[KindTypeLiteral-188] + _ = x[KindArrayType-189] + _ = x[KindTupleType-190] + _ = x[KindOptionalType-191] + _ = x[KindRestType-192] + _ = x[KindUnionType-193] + _ = x[KindIntersectionType-194] + _ = x[KindConditionalType-195] + _ = x[KindInferType-196] + _ = x[KindParenthesizedType-197] + _ = x[KindThisType-198] + _ = x[KindTypeOperator-199] + _ = x[KindIndexedAccessType-200] + _ = x[KindMappedType-201] + _ = x[KindLiteralType-202] + _ = x[KindNamedTupleMember-203] + _ = x[KindTemplateLiteralType-204] + _ = x[KindTemplateLiteralTypeSpan-205] + _ = x[KindImportType-206] + _ = x[KindObjectBindingPattern-207] + _ = x[KindArrayBindingPattern-208] + _ = x[KindBindingElement-209] + _ = x[KindArrayLiteralExpression-210] + _ = x[KindObjectLiteralExpression-211] + _ = x[KindPropertyAccessExpression-212] + _ = x[KindElementAccessExpression-213] + _ = x[KindCallExpression-214] + _ = x[KindNewExpression-215] + _ = x[KindTaggedTemplateExpression-216] + _ = x[KindTypeAssertionExpression-217] + _ = x[KindParenthesizedExpression-218] + _ = x[KindFunctionExpression-219] + _ = x[KindArrowFunction-220] + _ = x[KindDeleteExpression-221] + _ = x[KindTypeOfExpression-222] + _ = x[KindVoidExpression-223] + _ = x[KindAwaitExpression-224] + _ = x[KindPrefixUnaryExpression-225] + _ = x[KindPostfixUnaryExpression-226] + _ = x[KindBinaryExpression-227] + _ = x[KindConditionalExpression-228] + _ = x[KindTemplateExpression-229] + _ = x[KindYieldExpression-230] + _ = x[KindSpreadElement-231] + _ = x[KindClassExpression-232] + _ = x[KindOmittedExpression-233] + _ = x[KindExpressionWithTypeArguments-234] + _ = x[KindAsExpression-235] + _ = x[KindNonNullExpression-236] + _ = x[KindMetaProperty-237] + _ = x[KindSyntheticExpression-238] + _ = x[KindSatisfiesExpression-239] + _ = x[KindTemplateSpan-240] + _ = x[KindSemicolonClassElement-241] + _ = x[KindBlock-242] + _ = x[KindEmptyStatement-243] + _ = x[KindVariableStatement-244] + _ = x[KindExpressionStatement-245] + _ = x[KindIfStatement-246] + _ = x[KindDoStatement-247] + _ = x[KindWhileStatement-248] + _ = x[KindForStatement-249] + _ = x[KindForInStatement-250] + _ = x[KindForOfStatement-251] + _ = x[KindContinueStatement-252] + _ = x[KindBreakStatement-253] + _ = x[KindReturnStatement-254] + _ = x[KindWithStatement-255] + _ = x[KindSwitchStatement-256] + _ = x[KindLabeledStatement-257] + _ = x[KindThrowStatement-258] + _ = x[KindTryStatement-259] + _ = x[KindDebuggerStatement-260] + _ = x[KindVariableDeclaration-261] + _ = x[KindVariableDeclarationList-262] + _ = x[KindFunctionDeclaration-263] + _ = x[KindClassDeclaration-264] + _ = x[KindInterfaceDeclaration-265] + _ = x[KindTypeAliasDeclaration-266] + _ = x[KindEnumDeclaration-267] + _ = x[KindModuleDeclaration-268] + _ = x[KindModuleBlock-269] + _ = x[KindCaseBlock-270] + _ = x[KindNamespaceExportDeclaration-271] + _ = x[KindImportEqualsDeclaration-272] + _ = x[KindImportDeclaration-273] + _ = x[KindImportClause-274] + _ = x[KindNamespaceImport-275] + _ = x[KindNamedImports-276] + _ = x[KindImportSpecifier-277] + _ = x[KindExportAssignment-278] + _ = x[KindExportDeclaration-279] + _ = x[KindNamedExports-280] + _ = x[KindNamespaceExport-281] + _ = x[KindExportSpecifier-282] + _ = x[KindMissingDeclaration-283] + _ = x[KindExternalModuleReference-284] + _ = x[KindJsxElement-285] + _ = x[KindJsxSelfClosingElement-286] + _ = x[KindJsxOpeningElement-287] + _ = x[KindJsxClosingElement-288] + _ = x[KindJsxFragment-289] + _ = x[KindJsxOpeningFragment-290] + _ = x[KindJsxClosingFragment-291] + _ = x[KindJsxAttribute-292] + _ = x[KindJsxAttributes-293] + _ = x[KindJsxSpreadAttribute-294] + _ = x[KindJsxExpression-295] + _ = x[KindJsxNamespacedName-296] + _ = x[KindCaseClause-297] + _ = x[KindDefaultClause-298] + _ = x[KindHeritageClause-299] + _ = x[KindCatchClause-300] + _ = x[KindImportAttributes-301] + _ = x[KindImportAttribute-302] + _ = x[KindPropertyAssignment-303] + _ = x[KindShorthandPropertyAssignment-304] + _ = x[KindSpreadAssignment-305] + _ = x[KindEnumMember-306] + _ = x[KindSourceFile-307] + _ = x[KindBundle-308] + _ = x[KindJSDocTypeExpression-309] + _ = x[KindJSDocNameReference-310] + _ = x[KindJSDocMemberName-311] + _ = x[KindJSDocAllType-312] + _ = x[KindJSDocNullableType-313] + _ = x[KindJSDocNonNullableType-314] + _ = x[KindJSDocOptionalType-315] + _ = x[KindJSDocVariadicType-316] + _ = x[KindJSDoc-317] + _ = x[KindJSDocText-318] + _ = x[KindJSDocTypeLiteral-319] + _ = x[KindJSDocSignature-320] + _ = x[KindJSDocLink-321] + _ = x[KindJSDocLinkCode-322] + _ = x[KindJSDocLinkPlain-323] + _ = x[KindJSDocTag-324] + _ = x[KindJSDocAugmentsTag-325] + _ = x[KindJSDocImplementsTag-326] + _ = x[KindJSDocDeprecatedTag-327] + _ = x[KindJSDocPublicTag-328] + _ = x[KindJSDocPrivateTag-329] + _ = x[KindJSDocProtectedTag-330] + _ = x[KindJSDocReadonlyTag-331] + _ = x[KindJSDocOverrideTag-332] + _ = x[KindJSDocCallbackTag-333] + _ = x[KindJSDocOverloadTag-334] + _ = x[KindJSDocParameterTag-335] + _ = x[KindJSDocReturnTag-336] + _ = x[KindJSDocThisTag-337] + _ = x[KindJSDocTypeTag-338] + _ = x[KindJSDocTemplateTag-339] + _ = x[KindJSDocTypedefTag-340] + _ = x[KindJSDocSeeTag-341] + _ = x[KindJSDocPropertyTag-342] + _ = x[KindJSDocSatisfiesTag-343] + _ = x[KindJSDocImportTag-344] + _ = x[KindSyntaxList-345] + _ = x[KindJSTypeAliasDeclaration-346] + _ = x[KindJSExportAssignment-347] + _ = x[KindCommonJSExport-348] + _ = x[KindJSImportDeclaration-349] + _ = x[KindNotEmittedStatement-350] + _ = x[KindPartiallyEmittedExpression-351] + _ = x[KindCommaListExpression-352] + _ = x[KindSyntheticReferenceExpression-353] + _ = x[KindNotEmittedTypeElement-354] + _ = x[KindCount-355] } -const _Kind_name = "KindUnknownKindEndOfFileKindSingleLineCommentTriviaKindMultiLineCommentTriviaKindNewLineTriviaKindWhitespaceTriviaKindConflictMarkerTriviaKindNonTextFileMarkerTriviaKindNumericLiteralKindBigIntLiteralKindStringLiteralKindJsxTextKindJsxTextAllWhiteSpacesKindRegularExpressionLiteralKindNoSubstitutionTemplateLiteralKindTemplateHeadKindTemplateMiddleKindTemplateTailKindOpenBraceTokenKindCloseBraceTokenKindOpenParenTokenKindCloseParenTokenKindOpenBracketTokenKindCloseBracketTokenKindDotTokenKindDotDotDotTokenKindSemicolonTokenKindCommaTokenKindQuestionDotTokenKindLessThanTokenKindLessThanSlashTokenKindGreaterThanTokenKindLessThanEqualsTokenKindGreaterThanEqualsTokenKindEqualsEqualsTokenKindExclamationEqualsTokenKindEqualsEqualsEqualsTokenKindExclamationEqualsEqualsTokenKindEqualsGreaterThanTokenKindPlusTokenKindMinusTokenKindAsteriskTokenKindAsteriskAsteriskTokenKindSlashTokenKindPercentTokenKindPlusPlusTokenKindMinusMinusTokenKindLessThanLessThanTokenKindGreaterThanGreaterThanTokenKindGreaterThanGreaterThanGreaterThanTokenKindAmpersandTokenKindBarTokenKindCaretTokenKindExclamationTokenKindTildeTokenKindAmpersandAmpersandTokenKindBarBarTokenKindQuestionTokenKindColonTokenKindAtTokenKindQuestionQuestionTokenKindBacktickTokenKindHashTokenKindEqualsTokenKindPlusEqualsTokenKindMinusEqualsTokenKindAsteriskEqualsTokenKindAsteriskAsteriskEqualsTokenKindSlashEqualsTokenKindPercentEqualsTokenKindLessThanLessThanEqualsTokenKindGreaterThanGreaterThanEqualsTokenKindGreaterThanGreaterThanGreaterThanEqualsTokenKindAmpersandEqualsTokenKindBarEqualsTokenKindBarBarEqualsTokenKindAmpersandAmpersandEqualsTokenKindQuestionQuestionEqualsTokenKindCaretEqualsTokenKindIdentifierKindPrivateIdentifierKindJSDocCommentTextTokenKindBreakKeywordKindCaseKeywordKindCatchKeywordKindClassKeywordKindConstKeywordKindContinueKeywordKindDebuggerKeywordKindDefaultKeywordKindDeleteKeywordKindDoKeywordKindElseKeywordKindEnumKeywordKindExportKeywordKindExtendsKeywordKindFalseKeywordKindFinallyKeywordKindForKeywordKindFunctionKeywordKindIfKeywordKindImportKeywordKindInKeywordKindInstanceOfKeywordKindNewKeywordKindNullKeywordKindReturnKeywordKindSuperKeywordKindSwitchKeywordKindThisKeywordKindThrowKeywordKindTrueKeywordKindTryKeywordKindTypeOfKeywordKindVarKeywordKindVoidKeywordKindWhileKeywordKindWithKeywordKindImplementsKeywordKindInterfaceKeywordKindLetKeywordKindPackageKeywordKindPrivateKeywordKindProtectedKeywordKindPublicKeywordKindStaticKeywordKindYieldKeywordKindAbstractKeywordKindAccessorKeywordKindAsKeywordKindAssertsKeywordKindAssertKeywordKindAnyKeywordKindAsyncKeywordKindAwaitKeywordKindBooleanKeywordKindConstructorKeywordKindDeclareKeywordKindGetKeywordKindImmediateKeywordKindInferKeywordKindIntrinsicKeywordKindIsKeywordKindKeyOfKeywordKindModuleKeywordKindNamespaceKeywordKindNeverKeywordKindOutKeywordKindReadonlyKeywordKindRequireKeywordKindNumberKeywordKindObjectKeywordKindSatisfiesKeywordKindSetKeywordKindStringKeywordKindSymbolKeywordKindTypeKeywordKindUndefinedKeywordKindUniqueKeywordKindUnknownKeywordKindUsingKeywordKindFromKeywordKindGlobalKeywordKindBigIntKeywordKindOverrideKeywordKindOfKeywordKindQualifiedNameKindComputedPropertyNameKindTypeParameterKindParameterKindDecoratorKindPropertySignatureKindPropertyDeclarationKindMethodSignatureKindMethodDeclarationKindClassStaticBlockDeclarationKindConstructorKindGetAccessorKindSetAccessorKindCallSignatureKindConstructSignatureKindIndexSignatureKindTypePredicateKindTypeReferenceKindFunctionTypeKindConstructorTypeKindTypeQueryKindTypeLiteralKindArrayTypeKindTupleTypeKindOptionalTypeKindRestTypeKindUnionTypeKindIntersectionTypeKindConditionalTypeKindInferTypeKindParenthesizedTypeKindThisTypeKindTypeOperatorKindIndexedAccessTypeKindMappedTypeKindLiteralTypeKindNamedTupleMemberKindTemplateLiteralTypeKindTemplateLiteralTypeSpanKindImportTypeKindObjectBindingPatternKindArrayBindingPatternKindBindingElementKindArrayLiteralExpressionKindObjectLiteralExpressionKindPropertyAccessExpressionKindElementAccessExpressionKindCallExpressionKindNewExpressionKindTaggedTemplateExpressionKindTypeAssertionExpressionKindParenthesizedExpressionKindFunctionExpressionKindArrowFunctionKindDeleteExpressionKindTypeOfExpressionKindVoidExpressionKindAwaitExpressionKindPrefixUnaryExpressionKindPostfixUnaryExpressionKindBinaryExpressionKindConditionalExpressionKindTemplateExpressionKindYieldExpressionKindSpreadElementKindClassExpressionKindOmittedExpressionKindExpressionWithTypeArgumentsKindAsExpressionKindNonNullExpressionKindMetaPropertyKindSyntheticExpressionKindSatisfiesExpressionKindTemplateSpanKindSemicolonClassElementKindBlockKindEmptyStatementKindVariableStatementKindExpressionStatementKindIfStatementKindDoStatementKindWhileStatementKindForStatementKindForInStatementKindForOfStatementKindContinueStatementKindBreakStatementKindReturnStatementKindWithStatementKindSwitchStatementKindLabeledStatementKindThrowStatementKindTryStatementKindDebuggerStatementKindVariableDeclarationKindVariableDeclarationListKindFunctionDeclarationKindClassDeclarationKindInterfaceDeclarationKindTypeAliasDeclarationKindEnumDeclarationKindModuleDeclarationKindModuleBlockKindCaseBlockKindNamespaceExportDeclarationKindImportEqualsDeclarationKindImportDeclarationKindImportClauseKindNamespaceImportKindNamedImportsKindImportSpecifierKindExportAssignmentKindExportDeclarationKindNamedExportsKindNamespaceExportKindExportSpecifierKindMissingDeclarationKindExternalModuleReferenceKindJsxElementKindJsxSelfClosingElementKindJsxOpeningElementKindJsxClosingElementKindJsxFragmentKindJsxOpeningFragmentKindJsxClosingFragmentKindJsxAttributeKindJsxAttributesKindJsxSpreadAttributeKindJsxExpressionKindJsxNamespacedNameKindCaseClauseKindDefaultClauseKindHeritageClauseKindCatchClauseKindImportAttributesKindImportAttributeKindPropertyAssignmentKindShorthandPropertyAssignmentKindSpreadAssignmentKindEnumMemberKindSourceFileKindBundleKindJSDocTypeExpressionKindJSDocNameReferenceKindJSDocMemberNameKindJSDocAllTypeKindJSDocNullableTypeKindJSDocNonNullableTypeKindJSDocOptionalTypeKindJSDocVariadicTypeKindJSDocKindJSDocTextKindJSDocTypeLiteralKindJSDocSignatureKindJSDocLinkKindJSDocLinkCodeKindJSDocLinkPlainKindJSDocTagKindJSDocAugmentsTagKindJSDocImplementsTagKindJSDocDeprecatedTagKindJSDocPublicTagKindJSDocPrivateTagKindJSDocProtectedTagKindJSDocReadonlyTagKindJSDocOverrideTagKindJSDocCallbackTagKindJSDocOverloadTagKindJSDocParameterTagKindJSDocReturnTagKindJSDocThisTagKindJSDocTypeTagKindJSDocTemplateTagKindJSDocTypedefTagKindJSDocSeeTagKindJSDocPropertyTagKindJSDocSatisfiesTagKindJSDocImportTagKindSyntaxListKindJSTypeAliasDeclarationKindJSExportAssignmentKindCommonJSExportKindJSImportDeclarationKindNotEmittedStatementKindPartiallyEmittedExpressionKindCommaListExpressionKindSyntheticReferenceExpressionKindNotEmittedTypeElementKindCount" +const _Kind_name = "KindUnknownKindEndOfFileKindSingleLineCommentTriviaKindMultiLineCommentTriviaKindNewLineTriviaKindWhitespaceTriviaKindConflictMarkerTriviaKindNonTextFileMarkerTriviaKindNumericLiteralKindBigIntLiteralKindStringLiteralKindJsxTextKindJsxTextAllWhiteSpacesKindRegularExpressionLiteralKindNoSubstitutionTemplateLiteralKindTemplateHeadKindTemplateMiddleKindTemplateTailKindOpenBraceTokenKindCloseBraceTokenKindOpenParenTokenKindCloseParenTokenKindOpenBracketTokenKindCloseBracketTokenKindDotTokenKindDotDotDotTokenKindSemicolonTokenKindCommaTokenKindQuestionDotTokenKindLessThanTokenKindLessThanSlashTokenKindGreaterThanTokenKindLessThanEqualsTokenKindGreaterThanEqualsTokenKindEqualsEqualsTokenKindExclamationEqualsTokenKindEqualsEqualsEqualsTokenKindExclamationEqualsEqualsTokenKindEqualsGreaterThanTokenKindPlusTokenKindMinusTokenKindAsteriskTokenKindAsteriskAsteriskTokenKindSlashTokenKindPercentTokenKindPlusPlusTokenKindMinusMinusTokenKindLessThanLessThanTokenKindGreaterThanGreaterThanTokenKindGreaterThanGreaterThanGreaterThanTokenKindAmpersandTokenKindBarTokenKindCaretTokenKindExclamationTokenKindTildeTokenKindAmpersandAmpersandTokenKindBarBarTokenKindQuestionTokenKindColonTokenKindAtTokenKindQuestionQuestionTokenKindBacktickTokenKindHashTokenKindEqualsTokenKindPlusEqualsTokenKindMinusEqualsTokenKindAsteriskEqualsTokenKindAsteriskAsteriskEqualsTokenKindSlashEqualsTokenKindPercentEqualsTokenKindLessThanLessThanEqualsTokenKindGreaterThanGreaterThanEqualsTokenKindGreaterThanGreaterThanGreaterThanEqualsTokenKindAmpersandEqualsTokenKindBarEqualsTokenKindBarBarEqualsTokenKindAmpersandAmpersandEqualsTokenKindQuestionQuestionEqualsTokenKindCaretEqualsTokenKindIdentifierKindPrivateIdentifierKindJSDocCommentTextTokenKindBreakKeywordKindCaseKeywordKindCatchKeywordKindClassKeywordKindConstKeywordKindContinueKeywordKindDebuggerKeywordKindDefaultKeywordKindDeleteKeywordKindDoKeywordKindElseKeywordKindEnumKeywordKindExportKeywordKindExtendsKeywordKindFalseKeywordKindFinallyKeywordKindForKeywordKindFunctionKeywordKindIfKeywordKindImportKeywordKindInKeywordKindInstanceOfKeywordKindNewKeywordKindNullKeywordKindReturnKeywordKindSuperKeywordKindSwitchKeywordKindThisKeywordKindThrowKeywordKindTrueKeywordKindTryKeywordKindTypeOfKeywordKindVarKeywordKindVoidKeywordKindWhileKeywordKindWithKeywordKindImplementsKeywordKindInterfaceKeywordKindLetKeywordKindPackageKeywordKindPrivateKeywordKindProtectedKeywordKindPublicKeywordKindStaticKeywordKindYieldKeywordKindAbstractKeywordKindAccessorKeywordKindAsKeywordKindAssertsKeywordKindAssertKeywordKindAnyKeywordKindAsyncKeywordKindAwaitKeywordKindBooleanKeywordKindConstructorKeywordKindDeclareKeywordKindGetKeywordKindImmediateKeywordKindInferKeywordKindIntrinsicKeywordKindIsKeywordKindKeyOfKeywordKindModuleKeywordKindNamespaceKeywordKindNeverKeywordKindOutKeywordKindReadonlyKeywordKindRequireKeywordKindNumberKeywordKindObjectKeywordKindSatisfiesKeywordKindSetKeywordKindStringKeywordKindSymbolKeywordKindTypeKeywordKindUndefinedKeywordKindUniqueKeywordKindUnknownKeywordKindUsingKeywordKindFromKeywordKindGlobalKeywordKindBigIntKeywordKindOverrideKeywordKindOfKeywordKindDeferKeywordKindQualifiedNameKindComputedPropertyNameKindTypeParameterKindParameterKindDecoratorKindPropertySignatureKindPropertyDeclarationKindMethodSignatureKindMethodDeclarationKindClassStaticBlockDeclarationKindConstructorKindGetAccessorKindSetAccessorKindCallSignatureKindConstructSignatureKindIndexSignatureKindTypePredicateKindTypeReferenceKindFunctionTypeKindConstructorTypeKindTypeQueryKindTypeLiteralKindArrayTypeKindTupleTypeKindOptionalTypeKindRestTypeKindUnionTypeKindIntersectionTypeKindConditionalTypeKindInferTypeKindParenthesizedTypeKindThisTypeKindTypeOperatorKindIndexedAccessTypeKindMappedTypeKindLiteralTypeKindNamedTupleMemberKindTemplateLiteralTypeKindTemplateLiteralTypeSpanKindImportTypeKindObjectBindingPatternKindArrayBindingPatternKindBindingElementKindArrayLiteralExpressionKindObjectLiteralExpressionKindPropertyAccessExpressionKindElementAccessExpressionKindCallExpressionKindNewExpressionKindTaggedTemplateExpressionKindTypeAssertionExpressionKindParenthesizedExpressionKindFunctionExpressionKindArrowFunctionKindDeleteExpressionKindTypeOfExpressionKindVoidExpressionKindAwaitExpressionKindPrefixUnaryExpressionKindPostfixUnaryExpressionKindBinaryExpressionKindConditionalExpressionKindTemplateExpressionKindYieldExpressionKindSpreadElementKindClassExpressionKindOmittedExpressionKindExpressionWithTypeArgumentsKindAsExpressionKindNonNullExpressionKindMetaPropertyKindSyntheticExpressionKindSatisfiesExpressionKindTemplateSpanKindSemicolonClassElementKindBlockKindEmptyStatementKindVariableStatementKindExpressionStatementKindIfStatementKindDoStatementKindWhileStatementKindForStatementKindForInStatementKindForOfStatementKindContinueStatementKindBreakStatementKindReturnStatementKindWithStatementKindSwitchStatementKindLabeledStatementKindThrowStatementKindTryStatementKindDebuggerStatementKindVariableDeclarationKindVariableDeclarationListKindFunctionDeclarationKindClassDeclarationKindInterfaceDeclarationKindTypeAliasDeclarationKindEnumDeclarationKindModuleDeclarationKindModuleBlockKindCaseBlockKindNamespaceExportDeclarationKindImportEqualsDeclarationKindImportDeclarationKindImportClauseKindNamespaceImportKindNamedImportsKindImportSpecifierKindExportAssignmentKindExportDeclarationKindNamedExportsKindNamespaceExportKindExportSpecifierKindMissingDeclarationKindExternalModuleReferenceKindJsxElementKindJsxSelfClosingElementKindJsxOpeningElementKindJsxClosingElementKindJsxFragmentKindJsxOpeningFragmentKindJsxClosingFragmentKindJsxAttributeKindJsxAttributesKindJsxSpreadAttributeKindJsxExpressionKindJsxNamespacedNameKindCaseClauseKindDefaultClauseKindHeritageClauseKindCatchClauseKindImportAttributesKindImportAttributeKindPropertyAssignmentKindShorthandPropertyAssignmentKindSpreadAssignmentKindEnumMemberKindSourceFileKindBundleKindJSDocTypeExpressionKindJSDocNameReferenceKindJSDocMemberNameKindJSDocAllTypeKindJSDocNullableTypeKindJSDocNonNullableTypeKindJSDocOptionalTypeKindJSDocVariadicTypeKindJSDocKindJSDocTextKindJSDocTypeLiteralKindJSDocSignatureKindJSDocLinkKindJSDocLinkCodeKindJSDocLinkPlainKindJSDocTagKindJSDocAugmentsTagKindJSDocImplementsTagKindJSDocDeprecatedTagKindJSDocPublicTagKindJSDocPrivateTagKindJSDocProtectedTagKindJSDocReadonlyTagKindJSDocOverrideTagKindJSDocCallbackTagKindJSDocOverloadTagKindJSDocParameterTagKindJSDocReturnTagKindJSDocThisTagKindJSDocTypeTagKindJSDocTemplateTagKindJSDocTypedefTagKindJSDocSeeTagKindJSDocPropertyTagKindJSDocSatisfiesTagKindJSDocImportTagKindSyntaxListKindJSTypeAliasDeclarationKindJSExportAssignmentKindCommonJSExportKindJSImportDeclarationKindNotEmittedStatementKindPartiallyEmittedExpressionKindCommaListExpressionKindSyntheticReferenceExpressionKindNotEmittedTypeElementKindCount" -var _Kind_index = [...]uint16{0, 11, 24, 51, 77, 94, 114, 138, 165, 183, 200, 217, 228, 253, 281, 314, 330, 348, 364, 382, 401, 419, 438, 458, 479, 491, 509, 527, 541, 561, 578, 600, 620, 643, 669, 690, 716, 743, 775, 801, 814, 828, 845, 870, 884, 900, 917, 936, 961, 992, 1034, 1052, 1064, 1078, 1098, 1112, 1139, 1154, 1171, 1185, 1196, 1221, 1238, 1251, 1266, 1285, 1305, 1328, 1359, 1379, 1401, 1432, 1469, 1517, 1541, 1559, 1580, 1613, 1644, 1664, 1678, 1699, 1724, 1740, 1755, 1771, 1787, 1803, 1822, 1841, 1859, 1876, 1889, 1904, 1919, 1936, 1954, 1970, 1988, 2002, 2021, 2034, 2051, 2064, 2085, 2099, 2114, 2131, 2147, 2164, 2179, 2195, 2210, 2224, 2241, 2255, 2270, 2286, 2301, 2322, 2342, 2356, 2374, 2392, 2412, 2429, 2446, 2462, 2481, 2500, 2513, 2531, 2548, 2562, 2578, 2594, 2612, 2634, 2652, 2666, 2686, 2702, 2722, 2735, 2751, 2768, 2788, 2804, 2818, 2837, 2855, 2872, 2889, 2909, 2923, 2940, 2957, 2972, 2992, 3009, 3027, 3043, 3058, 3075, 3092, 3111, 3124, 3141, 3165, 3182, 3195, 3208, 3229, 3252, 3271, 3292, 3323, 3338, 3353, 3368, 3385, 3407, 3425, 3442, 3459, 3475, 3494, 3507, 3522, 3535, 3548, 3564, 3576, 3589, 3609, 3628, 3641, 3662, 3674, 3690, 3711, 3725, 3740, 3760, 3783, 3810, 3824, 3848, 3871, 3889, 3915, 3942, 3970, 3997, 4015, 4032, 4060, 4087, 4114, 4136, 4153, 4173, 4193, 4211, 4230, 4255, 4281, 4301, 4326, 4348, 4367, 4384, 4403, 4424, 4455, 4471, 4492, 4508, 4531, 4554, 4570, 4595, 4604, 4622, 4643, 4666, 4681, 4696, 4714, 4730, 4748, 4766, 4787, 4805, 4824, 4841, 4860, 4880, 4898, 4914, 4935, 4958, 4985, 5008, 5028, 5052, 5076, 5095, 5116, 5131, 5144, 5174, 5201, 5222, 5238, 5257, 5273, 5292, 5312, 5333, 5349, 5368, 5387, 5409, 5436, 5450, 5475, 5496, 5517, 5532, 5554, 5576, 5592, 5609, 5631, 5648, 5669, 5683, 5700, 5718, 5733, 5753, 5772, 5794, 5825, 5845, 5859, 5873, 5883, 5906, 5928, 5947, 5963, 5984, 6008, 6029, 6050, 6059, 6072, 6092, 6110, 6123, 6140, 6158, 6170, 6190, 6212, 6234, 6252, 6271, 6292, 6312, 6332, 6352, 6372, 6393, 6411, 6427, 6443, 6463, 6482, 6497, 6517, 6538, 6556, 6570, 6596, 6618, 6636, 6659, 6682, 6712, 6735, 6767, 6792, 6801} +var _Kind_index = [...]uint16{0, 11, 24, 51, 77, 94, 114, 138, 165, 183, 200, 217, 228, 253, 281, 314, 330, 348, 364, 382, 401, 419, 438, 458, 479, 491, 509, 527, 541, 561, 578, 600, 620, 643, 669, 690, 716, 743, 775, 801, 814, 828, 845, 870, 884, 900, 917, 936, 961, 992, 1034, 1052, 1064, 1078, 1098, 1112, 1139, 1154, 1171, 1185, 1196, 1221, 1238, 1251, 1266, 1285, 1305, 1328, 1359, 1379, 1401, 1432, 1469, 1517, 1541, 1559, 1580, 1613, 1644, 1664, 1678, 1699, 1724, 1740, 1755, 1771, 1787, 1803, 1822, 1841, 1859, 1876, 1889, 1904, 1919, 1936, 1954, 1970, 1988, 2002, 2021, 2034, 2051, 2064, 2085, 2099, 2114, 2131, 2147, 2164, 2179, 2195, 2210, 2224, 2241, 2255, 2270, 2286, 2301, 2322, 2342, 2356, 2374, 2392, 2412, 2429, 2446, 2462, 2481, 2500, 2513, 2531, 2548, 2562, 2578, 2594, 2612, 2634, 2652, 2666, 2686, 2702, 2722, 2735, 2751, 2768, 2788, 2804, 2818, 2837, 2855, 2872, 2889, 2909, 2923, 2940, 2957, 2972, 2992, 3009, 3027, 3043, 3058, 3075, 3092, 3111, 3124, 3140, 3157, 3181, 3198, 3211, 3224, 3245, 3268, 3287, 3308, 3339, 3354, 3369, 3384, 3401, 3423, 3441, 3458, 3475, 3491, 3510, 3523, 3538, 3551, 3564, 3580, 3592, 3605, 3625, 3644, 3657, 3678, 3690, 3706, 3727, 3741, 3756, 3776, 3799, 3826, 3840, 3864, 3887, 3905, 3931, 3958, 3986, 4013, 4031, 4048, 4076, 4103, 4130, 4152, 4169, 4189, 4209, 4227, 4246, 4271, 4297, 4317, 4342, 4364, 4383, 4400, 4419, 4440, 4471, 4487, 4508, 4524, 4547, 4570, 4586, 4611, 4620, 4638, 4659, 4682, 4697, 4712, 4730, 4746, 4764, 4782, 4803, 4821, 4840, 4857, 4876, 4896, 4914, 4930, 4951, 4974, 5001, 5024, 5044, 5068, 5092, 5111, 5132, 5147, 5160, 5190, 5217, 5238, 5254, 5273, 5289, 5308, 5328, 5349, 5365, 5384, 5403, 5425, 5452, 5466, 5491, 5512, 5533, 5548, 5570, 5592, 5608, 5625, 5647, 5664, 5685, 5699, 5716, 5734, 5749, 5769, 5788, 5810, 5841, 5861, 5875, 5889, 5899, 5922, 5944, 5963, 5979, 6000, 6024, 6045, 6066, 6075, 6088, 6108, 6126, 6139, 6156, 6174, 6186, 6206, 6228, 6250, 6268, 6287, 6308, 6328, 6348, 6368, 6388, 6409, 6427, 6443, 6459, 6479, 6498, 6513, 6533, 6554, 6572, 6586, 6612, 6634, 6652, 6675, 6698, 6728, 6751, 6783, 6808, 6817} func (i Kind) String() string { if i < 0 || i >= Kind(len(_Kind_index)-1) { diff --git a/internal/ast/precedence.go b/internal/ast/precedence.go index 26b001d362..e23d5278c9 100644 --- a/internal/ast/precedence.go +++ b/internal/ast/precedence.go @@ -43,15 +43,6 @@ const ( // ShortCircuitExpression // ShortCircuitExpression `?` AssignmentExpression `:` AssignmentExpression OperatorPrecedenceConditional - // ShortCircuitExpression: - // LogicalORExpression - // CoalesceExpression - // CoalesceExpression: - // CoalesceExpressionHead `??` BitwiseORExpression - // CoalesceExpressionHead: - // CoalesceExpression - // BitwiseORExpression - OperatorPrecedenceCoalesce // LogicalORExpression: // LogicalANDExpression // LogicalORExpression `||` LogicalANDExpression @@ -181,6 +172,15 @@ const ( OperatorPrecedenceLowest = OperatorPrecedenceComma OperatorPrecedenceHighest = OperatorPrecedenceParentheses OperatorPrecedenceDisallowComma = OperatorPrecedenceYield + // ShortCircuitExpression: + // LogicalORExpression + // CoalesceExpression + // CoalesceExpression: + // CoalesceExpressionHead `??` BitwiseORExpression + // CoalesceExpressionHead: + // CoalesceExpression + // BitwiseORExpression + OperatorPrecedenceCoalesce = OperatorPrecedenceLogicalOR // -1 is lower than all other precedences. Returning it will cause binary expression // parsing to stop. OperatorPrecedenceInvalid OperatorPrecedence = -1 diff --git a/internal/ast/utilities.go b/internal/ast/utilities.go index bb966aa237..25c4ca563a 100644 --- a/internal/ast/utilities.go +++ b/internal/ast/utilities.go @@ -1893,8 +1893,11 @@ func IsExpressionNode(node *Node) bool { KindClassExpression, KindArrowFunction, KindVoidExpression, KindDeleteExpression, KindTypeOfExpression, KindPrefixUnaryExpression, KindPostfixUnaryExpression, KindBinaryExpression, KindConditionalExpression, KindSpreadElement, KindTemplateExpression, KindOmittedExpression, KindJsxElement, KindJsxSelfClosingElement, - KindJsxFragment, KindYieldExpression, KindAwaitExpression, KindMetaProperty: + KindJsxFragment, KindYieldExpression, KindAwaitExpression: return true + case KindMetaProperty: + // `import.defer` in `import.defer(...)` is not an expression + return !IsImportCall(node.Parent) || node.Parent.AsCallExpression().Expression != node case KindExpressionWithTypeArguments: return !IsHeritageClause(node.Parent) case KindQualifiedName: @@ -2076,7 +2079,11 @@ func IsSuperCall(node *Node) bool { } func IsImportCall(node *Node) bool { - return IsCallExpression(node) && node.AsCallExpression().Expression.Kind == KindImportKeyword + if !IsCallExpression(node) { + return false + } + e := node.AsCallExpression().Expression + return e.Kind == KindImportKeyword || IsMetaProperty(e) && e.AsMetaProperty().KeywordToken == KindImportKeyword && e.Text() == "defer" } func IsComputedNonLiteralName(name *Node) bool { @@ -2641,7 +2648,7 @@ func GetNodeAtPosition(file *SourceFile, position int, includeJSDoc bool) *Node return false }) } - if child == nil { + if child == nil || IsMetaProperty(child) { return current } current = child @@ -2840,13 +2847,11 @@ func GetLeftmostAccessExpression(expr *Node) *Node { func IsTypeOnlyImportDeclaration(node *Node) bool { switch node.Kind { case KindImportSpecifier: - return node.AsImportSpecifier().IsTypeOnly || node.Parent.Parent.AsImportClause().IsTypeOnly + return node.IsTypeOnly() || node.Parent.Parent.IsTypeOnly() case KindNamespaceImport: - return node.Parent.AsImportClause().IsTypeOnly - case KindImportClause: - return node.AsImportClause().IsTypeOnly - case KindImportEqualsDeclaration: - return node.AsImportEqualsDeclaration().IsTypeOnly + return node.Parent.IsTypeOnly() + case KindImportClause, KindImportEqualsDeclaration: + return node.IsTypeOnly() } return false } @@ -2874,11 +2879,11 @@ func IsExclusivelyTypeOnlyImportOrExport(node *Node) bool { return node.AsExportDeclaration().IsTypeOnly case KindImportDeclaration, KindJSImportDeclaration: if importClause := node.AsImportDeclaration().ImportClause; importClause != nil { - return importClause.AsImportClause().IsTypeOnly + return importClause.AsImportClause().IsTypeOnly() } case KindJSDocImportTag: if importClause := node.AsJSDocImportTag().ImportClause; importClause != nil { - return importClause.AsImportClause().IsTypeOnly + return importClause.AsImportClause().IsTypeOnly() } } return false @@ -3509,9 +3514,9 @@ func IsTypeDeclaration(node *Node) bool { case KindTypeParameter, KindClassDeclaration, KindInterfaceDeclaration, KindTypeAliasDeclaration, KindJSTypeAliasDeclaration, KindEnumDeclaration: return true case KindImportClause: - return node.AsImportClause().IsTypeOnly + return node.AsImportClause().PhaseModifier == KindTypeKeyword case KindImportSpecifier: - return node.Parent.Parent.AsImportClause().IsTypeOnly + return node.Parent.Parent.AsImportClause().PhaseModifier == KindTypeKeyword case KindExportSpecifier: return node.Parent.Parent.AsExportDeclaration().IsTypeOnly default: diff --git a/internal/binder/binder.go b/internal/binder/binder.go index a2e30cde4f..e113b2505e 100644 --- a/internal/binder/binder.go +++ b/internal/binder/binder.go @@ -447,9 +447,9 @@ func (b *Binder) declareSymbolAndAddToSymbolTable(node *ast.Node, symbolFlags as return b.declareClassMember(node, symbolFlags, symbolExcludes) case ast.KindEnumDeclaration: return b.declareSymbol(ast.GetExports(b.container.Symbol()), b.container.Symbol(), node, symbolFlags, symbolExcludes) - case ast.KindTypeLiteral, ast.KindJSDocTypeLiteral, ast.KindObjectLiteralExpression, ast.KindInterfaceDeclaration, ast.KindJsxAttributes: + case ast.KindTypeLiteral, ast.KindObjectLiteralExpression, ast.KindInterfaceDeclaration, ast.KindJsxAttributes: return b.declareSymbol(ast.GetMembers(b.container.Symbol()), b.container.Symbol(), node, symbolFlags, symbolExcludes) - case ast.KindFunctionType, ast.KindConstructorType, ast.KindCallSignature, ast.KindConstructSignature, ast.KindJSDocSignature, + case ast.KindFunctionType, ast.KindConstructorType, ast.KindCallSignature, ast.KindConstructSignature, ast.KindIndexSignature, ast.KindMethodDeclaration, ast.KindMethodSignature, ast.KindConstructor, ast.KindGetAccessor, ast.KindSetAccessor, ast.KindFunctionDeclaration, ast.KindFunctionExpression, ast.KindArrowFunction, ast.KindClassStaticBlockDeclaration, ast.KindTypeAliasDeclaration, ast.KindJSTypeAliasDeclaration, ast.KindMappedType: @@ -676,10 +676,8 @@ func (b *Binder) bind(node *ast.Node) bool { case ast.KindSetAccessor: b.bindPropertyOrMethodOrAccessor(node, ast.SymbolFlagsSetAccessor, ast.SymbolFlagsSetAccessorExcludes) case ast.KindFunctionType, ast.KindConstructorType: - // !!! KindJSDocSignature b.bindFunctionOrConstructorType(node) case ast.KindTypeLiteral, ast.KindMappedType: - // !!! KindJSDocTypeLiteral b.bindAnonymousDeclaration(node, ast.SymbolFlagsTypeLiteral, ast.InternalSymbolNameType) case ast.KindObjectLiteralExpression: b.bindAnonymousDeclaration(node, ast.SymbolFlagsObjectLiteral, ast.InternalSymbolNameObject) @@ -1125,10 +1123,6 @@ func (b *Binder) bindVariableDeclarationOrBindingElement(node *ast.Node) { } func (b *Binder) bindParameter(node *ast.Node) { - // !!! - // if node.kind == KindJSDocParameterTag && b.container.kind != KindJSDocSignature { - // return - // } decl := node.AsParameterDeclaration() if b.inStrictMode && node.Flags&ast.NodeFlagsAmbient == 0 { // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a @@ -1194,17 +1188,6 @@ func (b *Binder) bindBlockScopedDeclaration(node *ast.Node, symbolFlags ast.Symb } func (b *Binder) bindTypeParameter(node *ast.Node) { - // !!! - // if isJSDocTemplateTag(node.parent) { - // var container *HasLocals = getEffectiveContainerForJSDocTemplateTag(node.parent) - // if container { - // Debug.assertNode(container, canHaveLocals) - // /* TODO(TS-TO-GO) QuestionQuestionEqualsToken BinaryExpression: container.locals ??= createSymbolTable() */ TODO - // b.declareSymbol(container.locals /*parent*/, nil, node, SymbolFlagsTypeParameter, SymbolFlagsTypeParameterExcludes) - // } else { - // b.declareSymbolAndAddToSymbolTable(node, SymbolFlagsTypeParameter, SymbolFlagsTypeParameterExcludes) - // } - // } if node.Parent.Kind == ast.KindInferType { container := b.getInferTypeContainer(node.Parent) if container != nil { @@ -1646,10 +1629,6 @@ func (b *Binder) bindChildren(node *ast.Node) { b.bindCallExpressionFlow(node) case ast.KindNonNullExpression: b.bindNonNullExpressionFlow(node) - // case *JSDocTypedefTag, *JSDocCallbackTag, *JSDocEnumTag: - // b.bindJSDocTypeAlias(node) - // case *JSDocImportTag: - // b.bindJSDocImportTag(node) case ast.KindSourceFile: sourceFile := node.AsSourceFile() b.bindEachStatementFunctionsFirst(sourceFile.Statements) @@ -2578,7 +2557,7 @@ func SetValueDeclaration(symbol *ast.Symbol, node *ast.Node) { func GetContainerFlags(node *ast.Node) ContainerFlags { switch node.Kind { case ast.KindClassExpression, ast.KindClassDeclaration, ast.KindEnumDeclaration, ast.KindObjectLiteralExpression, ast.KindTypeLiteral, - ast.KindJSDocTypeLiteral, ast.KindJsxAttributes: + ast.KindJsxAttributes: return ContainerFlagsIsContainer case ast.KindInterfaceDeclaration: return ContainerFlagsIsContainer | ContainerFlagsIsInterface @@ -2593,7 +2572,7 @@ func GetContainerFlags(node *ast.Node) ContainerFlags { fallthrough case ast.KindConstructor, ast.KindClassStaticBlockDeclaration: return ContainerFlagsIsContainer | ContainerFlagsIsControlFlowContainer | ContainerFlagsHasLocals | ContainerFlagsIsFunctionLike | ContainerFlagsIsThisContainer - case ast.KindMethodSignature, ast.KindCallSignature, ast.KindJSDocSignature, ast.KindFunctionType, ast.KindConstructSignature, ast.KindConstructorType: + case ast.KindMethodSignature, ast.KindCallSignature, ast.KindFunctionType, ast.KindConstructSignature, ast.KindConstructorType: return ContainerFlagsIsContainer | ContainerFlagsIsControlFlowContainer | ContainerFlagsHasLocals | ContainerFlagsIsFunctionLike case ast.KindFunctionDeclaration: return ContainerFlagsIsContainer | ContainerFlagsIsControlFlowContainer | ContainerFlagsHasLocals | ContainerFlagsIsFunctionLike | ContainerFlagsIsThisContainer @@ -2630,9 +2609,6 @@ func isNarrowingExpression(expr *ast.Node) bool { case ast.KindCallExpression: return hasNarrowableArgument(expr) case ast.KindParenthesizedExpression: - // if isJSDocTypeAssertion(expr) { - // return false - // } return isNarrowingExpression(expr.AsParenthesizedExpression().Expression) case ast.KindNonNullExpression: return isNarrowingExpression(expr.AsNonNullExpression().Expression) diff --git a/internal/checker/checker.go b/internal/checker/checker.go index 124783eaa1..aa519a1046 100644 --- a/internal/checker/checker.go +++ b/internal/checker/checker.go @@ -1951,7 +1951,7 @@ func (c *Checker) isBlockScopedNameDeclaredBeforeUse(declaration *ast.Node, usag func (c *Checker) isUsedInFunctionOrInstanceProperty(usage *ast.Node, declaration *ast.Node, declContainer *ast.Node) bool { for current := usage; current != nil && current != declContainer; current = current.Parent { if ast.IsFunctionLike(current) { - return true + return ast.GetImmediatelyInvokedFunctionExpression(current) == nil } if ast.IsClassStaticBlockDeclaration(current) { return declaration.Pos() < usage.Pos() @@ -1978,6 +1978,15 @@ func (c *Checker) isUsedInFunctionOrInstanceProperty(usage *ast.Node, declaratio } } } + if current.Parent != nil && ast.IsDecorator(current.Parent) && current.Parent.AsDecorator().Expression == current { + decorator := current.Parent.AsDecorator() + if ast.IsParameter(decorator.Parent) { + return c.isUsedInFunctionOrInstanceProperty(decorator.Parent.Parent.Parent, declaration, declContainer) + } + if ast.IsMethodDeclaration(decorator.Parent) { + return c.isUsedInFunctionOrInstanceProperty(decorator.Parent.Parent, declaration, declContainer) + } + } } return false } @@ -7060,7 +7069,7 @@ func (c *Checker) getQuickTypeOfExpression(node *ast.Node) *Type { return nil // Optimize for the common case of a call to a function with a single non-generic call // signature where we can just fetch the return type without checking the arguments. - case ast.IsCallExpression(expr) && expr.Expression().Kind != ast.KindSuperKeyword && !ast.IsRequireCall(expr, true /*requireStringLiteralLikeArgument*/) && !c.isSymbolOrSymbolForCall(expr): + case ast.IsCallExpression(expr) && expr.Expression().Kind != ast.KindSuperKeyword && !ast.IsRequireCall(expr, true /*requireStringLiteralLikeArgument*/) && !c.isSymbolOrSymbolForCall(expr) && !ast.IsImportCall(expr): if isCallChain(expr) { return c.getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) } @@ -7456,7 +7465,7 @@ func (c *Checker) checkExpressionWorker(node *ast.Node, checkMode CheckMode) *Ty case ast.KindElementAccessExpression: return c.checkIndexedAccess(node, checkMode) case ast.KindCallExpression: - if node.AsCallExpression().Expression.Kind == ast.KindImportKeyword { + if ast.IsImportCall(node) { return c.checkImportCallExpression(node) } return c.checkCallExpression(node, checkMode) @@ -9872,7 +9881,7 @@ func (c *Checker) contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node inferenceContext := c.getInferenceContext(node) var instantiatedContextualSignature *Signature if checkMode&CheckModeInferential != 0 { - c.inferFromAnnotatedParameters(signature, contextualSignature, inferenceContext) + c.inferFromAnnotatedParametersAndReturn(signature, contextualSignature, inferenceContext) restType := c.getEffectiveRestType(contextualSignature) if restType != nil && restType.flags&TypeFlagsTypeParameter != 0 { instantiatedContextualSignature = c.instantiateSignature(contextualSignature, inferenceContext.nonFixingMapper) @@ -9893,7 +9902,7 @@ func (c *Checker) contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node } else if contextualSignature != nil && node.TypeParameters() == nil && len(contextualSignature.parameters) > len(node.Parameters()) { inferenceContext := c.getInferenceContext(node) if checkMode&CheckModeInferential != 0 { - c.inferFromAnnotatedParameters(signature, contextualSignature, inferenceContext) + c.inferFromAnnotatedParametersAndReturn(signature, contextualSignature, inferenceContext) } } if contextualSignature != nil && c.getReturnTypeFromAnnotation(node) == nil && signature.resolvedReturnType == nil { @@ -9940,7 +9949,7 @@ func (c *Checker) checkFunctionExpressionOrObjectLiteralMethodDeferred(node *ast } } -func (c *Checker) inferFromAnnotatedParameters(sig *Signature, context *Signature, inferenceContext *InferenceContext) { +func (c *Checker) inferFromAnnotatedParametersAndReturn(sig *Signature, context *Signature, inferenceContext *InferenceContext) { length := len(sig.parameters) - core.IfElse(signatureHasRestParameter(sig), 1, 0) for i := range length { declaration := sig.parameters[i].ValueDeclaration @@ -9951,6 +9960,13 @@ func (c *Checker) inferFromAnnotatedParameters(sig *Signature, context *Signatur c.inferTypes(inferenceContext.inferences, source, target, InferencePriorityNone, false) } } + if declaration := sig.Declaration(); declaration != nil { + if returnTypeNode := declaration.Type(); returnTypeNode != nil { + source := c.getTypeFromTypeNode(returnTypeNode) + target := c.getReturnTypeOfSignature(context) + c.inferTypes(inferenceContext.inferences, source, target, InferencePriorityNone, false) + } + } } // Return the contextual signature for a given expression node. A contextual type provides a @@ -10342,6 +10358,10 @@ func (c *Checker) checkMetaProperty(node *ast.Node) *Type { case ast.KindNewKeyword: return c.checkNewTargetMetaProperty(node) case ast.KindImportKeyword: + if node.Name().Text() == "defer" { + debug.Assert(!ast.IsCallExpression(node.Parent) || node.Parent.AsCallExpression().Expression != node, "Trying to get the type of `import.defer` in `import.defer(...)`") + return c.errorType + } return c.checkImportMetaProperty(node) } panic("Unhandled case in checkMetaProperty") @@ -10621,7 +10641,7 @@ func (c *Checker) checkIdentifier(node *ast.Node, checkMode CheckMode) *Type { return c.errorType } if symbol == c.argumentsSymbol { - if c.isInPropertyInitializerOrClassStaticBlock(node) { + if c.isInPropertyInitializerOrClassStaticBlock(node, true /*ignoreArrowFunctions*/) { c.error(node, diagnostics.X_arguments_cannot_be_referenced_in_property_initializers_or_class_static_initialization_blocks) return c.errorType } @@ -11258,7 +11278,7 @@ func (c *Checker) checkPropertyNotUsedBeforeDeclaration(prop *ast.Symbol, node * } var diagnostic *ast.Diagnostic declarationName := right.Text() - if c.isInPropertyInitializerOrClassStaticBlock(node) && + if c.isInPropertyInitializerOrClassStaticBlock(node, false /*ignoreArrowFunctions*/) && !c.isOptionalPropertyDeclaration(valueDeclaration) && !(ast.IsAccessExpression(node) && ast.IsAccessExpression(node.Expression())) && !c.isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right) && @@ -12446,23 +12466,49 @@ func (c *Checker) getSyntacticTruthySemantics(node *ast.Node) PredicateSemantics } func (c *Checker) checkNullishCoalesceOperands(left *ast.Node, right *ast.Node) { - if ast.IsBinaryExpression(left) && ast.IsLogicalBinaryOperator(left.AsBinaryExpression().OperatorToken.Kind) { - c.grammarErrorOnNode(left, diagnostics.X_0_and_1_operations_cannot_be_mixed_without_parentheses, scanner.TokenToString(left.AsBinaryExpression().OperatorToken.Kind), scanner.TokenToString(ast.KindQuestionQuestionToken)) - } - if ast.IsBinaryExpression(right) && ast.IsLogicalBinaryOperator(right.AsBinaryExpression().OperatorToken.Kind) { - c.grammarErrorOnNode(right, diagnostics.X_0_and_1_operations_cannot_be_mixed_without_parentheses, scanner.TokenToString(right.AsBinaryExpression().OperatorToken.Kind), scanner.TokenToString(ast.KindQuestionQuestionToken)) + if ast.IsBinaryExpression(left.Parent.Parent) { + grandparentLeft := left.Parent.Parent.AsBinaryExpression().Left + grandparentOperatorToken := left.Parent.Parent.AsBinaryExpression().OperatorToken + if ast.IsBinaryExpression(grandparentLeft) && grandparentOperatorToken.Kind == ast.KindBarBarToken { + c.grammarErrorOnNode(grandparentLeft, diagnostics.X_0_and_1_operations_cannot_be_mixed_without_parentheses, scanner.TokenToString(ast.KindQuestionQuestionToken), scanner.TokenToString(grandparentOperatorToken.Kind)) + } + } else if ast.IsBinaryExpression(left) { + operatorToken := left.AsBinaryExpression().OperatorToken + if operatorToken.Kind == ast.KindBarBarToken || operatorToken.Kind == ast.KindAmpersandAmpersandToken { + c.grammarErrorOnNode(left, diagnostics.X_0_and_1_operations_cannot_be_mixed_without_parentheses, scanner.TokenToString(operatorToken.Kind), scanner.TokenToString(ast.KindQuestionQuestionToken)) + } + } else if ast.IsBinaryExpression(right) { + operatorToken := right.AsBinaryExpression().OperatorToken + if operatorToken.Kind == ast.KindAmpersandAmpersandToken { + c.grammarErrorOnNode(right, diagnostics.X_0_and_1_operations_cannot_be_mixed_without_parentheses, scanner.TokenToString(ast.KindQuestionQuestionToken), scanner.TokenToString(operatorToken.Kind)) + } } + c.checkNullishCoalesceOperandLeft(left) + c.checkNullishCoalesceOperandRight(right) +} + +func (c *Checker) checkNullishCoalesceOperandLeft(left *ast.Node) { leftTarget := ast.SkipOuterExpressions(left, ast.OEKAll) nullishSemantics := c.getSyntacticNullishnessSemantics(leftTarget) if nullishSemantics != PredicateSemanticsSometimes { - if left.Parent.Parent.Kind == ast.KindBinaryExpression { - c.error(leftTarget, diagnostics.This_binary_expression_is_never_nullish_Are_you_missing_parentheses) + if nullishSemantics == PredicateSemanticsAlways { + c.error(leftTarget, diagnostics.This_expression_is_always_nullish) } else { - if nullishSemantics == PredicateSemanticsAlways { - c.error(leftTarget, diagnostics.This_expression_is_always_nullish) - } else { - c.error(leftTarget, diagnostics.Right_operand_of_is_unreachable_because_the_left_operand_is_never_nullish) - } + c.error(leftTarget, diagnostics.Right_operand_of_is_unreachable_because_the_left_operand_is_never_nullish) + } + } +} + +func (c *Checker) checkNullishCoalesceOperandRight(right *ast.Node) { + binaryExpression := right.Parent + if binaryExpression.Parent != nil && ast.IsBinaryExpression(binaryExpression.Parent) && binaryExpression.Parent.AsBinaryExpression().OperatorToken.Kind == ast.KindQuestionQuestionToken { + rightTarget := ast.SkipOuterExpressions(right, ast.OEKAll) + nullishSemantics := c.getSyntacticNullishnessSemantics(rightTarget) + switch nullishSemantics { + case PredicateSemanticsAlways: + c.error(rightTarget, diagnostics.This_expression_is_always_nullish) + case PredicateSemanticsNever: + c.error(rightTarget, diagnostics.This_expression_is_never_nullish) } } } @@ -13182,25 +13228,19 @@ func (c *Checker) checkShorthandPropertyAssignment(node *ast.Node, inDestructuri return expressionType } -func (c *Checker) isInPropertyInitializerOrClassStaticBlock(node *ast.Node) bool { +func (c *Checker) isInPropertyInitializerOrClassStaticBlock(node *ast.Node, ignoreArrowFunctions bool) bool { return ast.FindAncestorOrQuit(node, func(node *ast.Node) ast.FindAncestorResult { switch node.Kind { - case ast.KindPropertyDeclaration: + case ast.KindPropertyDeclaration, ast.KindClassStaticBlockDeclaration: return ast.FindAncestorTrue - case ast.KindPropertyAssignment, ast.KindMethodDeclaration, ast.KindGetAccessor, ast.KindSetAccessor, ast.KindSpreadAssignment, - ast.KindComputedPropertyName, ast.KindTemplateSpan, ast.KindJsxExpression, ast.KindJsxAttribute, ast.KindJsxAttributes, - ast.KindJsxSpreadAttribute, ast.KindJsxOpeningElement, ast.KindExpressionWithTypeArguments, ast.KindHeritageClause: - return ast.FindAncestorFalse - case ast.KindArrowFunction, ast.KindExpressionStatement: - if ast.IsBlock(node.Parent) && ast.IsClassStaticBlockDeclaration(node.Parent.Parent) { - return ast.FindAncestorTrue - } + case ast.KindTypeQuery, ast.KindJsxClosingElement: return ast.FindAncestorQuit + case ast.KindArrowFunction: + return core.IfElse(ignoreArrowFunctions, ast.FindAncestorFalse, ast.FindAncestorQuit) + case ast.KindBlock: + return core.IfElse(ast.IsFunctionLikeDeclaration(node.Parent) && node.Parent.Kind != ast.KindArrowFunction, ast.FindAncestorQuit, ast.FindAncestorFalse) default: - if ast.IsExpressionNode(node) { - return ast.FindAncestorFalse - } - return ast.FindAncestorQuit + return ast.FindAncestorFalse } }) != nil } @@ -15499,9 +15539,7 @@ func (c *Checker) addDeclarationToLateBoundSymbol(symbol *ast.Symbol, member *as symbol.Declarations = append(symbol.Declarations, member) } if symbolFlags&ast.SymbolFlagsValue != 0 { - if symbol.ValueDeclaration == nil || symbol.ValueDeclaration.Kind != member.Kind { - symbol.ValueDeclaration = member - } + binder.SetValueDeclaration(symbol, member) } } @@ -15806,14 +15844,14 @@ func (c *Checker) getWriteTypeOfSymbolWithDeferredType(symbol *ast.Symbol) *Type // properties deriving from set accessors will either pre-compute or defer the union or // intersection of the writeTypes of their constituents. func (c *Checker) getWriteTypeOfSymbol(symbol *ast.Symbol) *Type { - if symbol.Flags&ast.SymbolFlagsProperty != 0 { - if symbol.CheckFlags&ast.CheckFlagsSyntheticProperty != 0 { - if symbol.CheckFlags&ast.CheckFlagsDeferredType != 0 { - return c.getWriteTypeOfSymbolWithDeferredType(symbol) - } - links := c.valueSymbolLinks.Get(symbol) - return core.OrElse(links.writeType, links.resolvedType) + if symbol.CheckFlags&ast.CheckFlagsSyntheticProperty != 0 { + if symbol.CheckFlags&ast.CheckFlagsDeferredType != 0 { + return c.getWriteTypeOfSymbolWithDeferredType(symbol) } + links := c.valueSymbolLinks.Get(symbol) + return core.OrElse(links.writeType, links.resolvedType) + } + if symbol.Flags&ast.SymbolFlagsProperty != 0 { return c.removeMissingType(c.getTypeOfSymbol(symbol), symbol.Flags&ast.SymbolFlagsOptional != 0) } if symbol.Flags&ast.SymbolFlagsAccessor != 0 { @@ -20714,6 +20752,7 @@ func (c *Checker) getUnionOrIntersectionProperty(t *Type, name string, skipObjec } func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name string, skipObjectFunctionPropertyAugment bool) *ast.Symbol { + propFlags := ast.SymbolFlagsNone var singleProp *ast.Symbol var propSet collections.OrderedSet[*ast.Symbol] var indexTypes []*Type @@ -20743,6 +20782,7 @@ func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name s } if singleProp == nil { singleProp = prop + propFlags = core.OrElse(prop.Flags&ast.SymbolFlagsAccessor, ast.SymbolFlagsProperty) } else if prop != singleProp { isInstantiation := c.getTargetSymbol(prop) == c.getTargetSymbol(singleProp) // If the symbols are instances of one another with identical types - consider the symbols @@ -20759,6 +20799,13 @@ func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name s } propSet.Add(prop) } + // classes created by mixins are represented as intersections + // and overriding a property in a derived class redefines it completely at runtime + // so a get accessor can't be merged with a set accessor in a base class, + // for that reason the accessor flags are only used when they are the same in all constituents + if propFlags&ast.SymbolFlagsAccessor != 0 && (prop.Flags&ast.SymbolFlagsAccessor != (propFlags & ast.SymbolFlagsAccessor)) { + propFlags = (propFlags &^ ast.SymbolFlagsAccessor) | ast.SymbolFlagsProperty + } } if isUnion && c.isReadonlySymbol(prop) { checkFlags |= ast.CheckFlagsReadonly @@ -20786,6 +20833,7 @@ func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name s indexInfo = c.getApplicableIndexInfoForName(t, name) } if indexInfo != nil { + propFlags = propFlags&^ast.SymbolFlagsAccessor | ast.SymbolFlagsProperty checkFlags |= ast.CheckFlagsWritePartial | (core.IfElse(indexInfo.isReadonly, ast.CheckFlagsReadonly, 0)) if isTupleType(t) { indexType := c.getRestTypeOfTupleType(t) @@ -20878,7 +20926,7 @@ func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name s propTypes = append(propTypes, t) } propTypes = append(propTypes, indexTypes...) - result := c.newSymbolEx(ast.SymbolFlagsProperty|optionalFlag, name, checkFlags|syntheticFlag) + result := c.newSymbolEx(propFlags|optionalFlag, name, checkFlags|syntheticFlag) result.Declarations = declarations if !hasNonUniformValueDeclaration && firstValueDeclaration != nil { result.ValueDeclaration = firstValueDeclaration @@ -23175,6 +23223,8 @@ func (c *Checker) computeEnumMemberValues(node *ast.Node) { func (c *Checker) computeEnumMemberValue(member *ast.Node, autoValue jsnum.Number, previous *ast.Node) evaluator.Result { if ast.IsComputedNonLiteralName(member.Name()) { c.error(member.Name(), diagnostics.Computed_property_names_are_not_allowed_in_enums) + } else if ast.IsBigIntLiteral(member.Name()) { + c.error(member.Name(), diagnostics.An_enum_member_cannot_have_a_numeric_name) } else { text := ast.GetTextOfPropertyName(member.Name()) if isNumericLiteralName(text) && !isInfinityOrNaNString(text) { @@ -30473,7 +30523,12 @@ func (c *Checker) getSymbolAtLocation(node *ast.Node, ignoreErrors bool) *ast.Sy return parent.Symbol() } return nil - case ast.KindImportKeyword, ast.KindNewKeyword: + case ast.KindImportKeyword: + if ast.IsMetaProperty(node.Parent) && node.Parent.Text() == "defer" { + return nil + } + fallthrough + case ast.KindNewKeyword: if ast.IsMetaProperty(parent) { return c.checkMetaPropertyKeyword(parent).symbol } diff --git a/internal/checker/emitresolver.go b/internal/checker/emitresolver.go index 0bc6f07d42..1901c17e7a 100644 --- a/internal/checker/emitresolver.go +++ b/internal/checker/emitresolver.go @@ -409,7 +409,14 @@ func (r *emitResolver) hasVisibleDeclarations(symbol *ast.Symbol, shouldComputeA continue } if symbol.Flags&ast.SymbolFlagsBlockScopedVariable != 0 { - variableStatement := ast.FindAncestor(declaration, ast.IsVariableStatement) + rootDeclaration := ast.WalkUpBindingElementsAndPatterns(declaration) + if ast.IsParameter(rootDeclaration) { + return nil + } + variableStatement := rootDeclaration.Parent.Parent + if !ast.IsVariableStatement(variableStatement) { + return nil + } if ast.HasSyntacticModifier(variableStatement, ast.ModifierFlagsExport) { continue // no alias to add, already exported } diff --git a/internal/checker/flow.go b/internal/checker/flow.go index 6ff6acbf4c..eafd7fde95 100644 --- a/internal/checker/flow.go +++ b/internal/checker/flow.go @@ -1427,7 +1427,7 @@ func (c *Checker) getCandidateDiscriminantPropertyAccess(f *FlowState, expr *ast // parameter declared in the same parameter list is a candidate. if ast.IsIdentifier(expr) { symbol := c.getResolvedSymbol(expr) - declaration := symbol.ValueDeclaration + declaration := c.getExportSymbolOfValueSymbolIfExported(symbol).ValueDeclaration if declaration != nil && (ast.IsBindingElement(declaration) || ast.IsParameter(declaration)) && f.reference == declaration.Parent && declaration.Initializer() == nil && !hasDotDotDotToken(declaration) { return declaration } diff --git a/internal/checker/grammarchecks.go b/internal/checker/grammarchecks.go index 9ad9476d0a..75943613bf 100644 --- a/internal/checker/grammarchecks.go +++ b/internal/checker/grammarchecks.go @@ -37,7 +37,7 @@ func (c *Checker) grammarErrorAtPos(nodeForSourceFile *ast.Node, start int, leng func (c *Checker) grammarErrorOnNode(node *ast.Node, message *diagnostics.Message, args ...any) bool { sourceFile := ast.GetSourceFileOfNode(node) if !c.hasParseDiagnostics(sourceFile) { - c.diagnostics.Add(NewDiagnosticForNode(node, message, args...)) + c.error(node, message, args...) return true } return false @@ -1700,8 +1700,13 @@ func (c *Checker) checkGrammarVariableDeclarationList(declarationList *ast.Varia } blockScopeFlags := declarationList.Flags & ast.NodeFlagsBlockScoped - if (blockScopeFlags == ast.NodeFlagsUsing || blockScopeFlags == ast.NodeFlagsAwaitUsing) && ast.IsForInStatement(declarationList.Parent) { - return c.grammarErrorOnNode(declarationList.AsNode(), core.IfElse(blockScopeFlags == ast.NodeFlagsUsing, diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_using_declaration, diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_an_await_using_declaration)) + if blockScopeFlags == ast.NodeFlagsUsing || blockScopeFlags == ast.NodeFlagsAwaitUsing { + if ast.IsForInStatement(declarationList.Parent) { + return c.grammarErrorOnNode(declarationList.AsNode(), core.IfElse(blockScopeFlags == ast.NodeFlagsUsing, diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_using_declaration, diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_an_await_using_declaration)) + } + if declarationList.Flags&ast.NodeFlagsAmbient != 0 { + return c.grammarErrorOnNode(declarationList.AsNode(), core.IfElse(blockScopeFlags == ast.NodeFlagsUsing, diagnostics.X_using_declarations_are_not_allowed_in_ambient_contexts, diagnostics.X_await_using_declarations_are_not_allowed_in_ambient_contexts)) + } } if blockScopeFlags == ast.NodeFlagsAwaitUsing { @@ -1841,7 +1846,7 @@ func (c *Checker) checkGrammarForDisallowedBlockScopedVariableStatement(node *as default: panic("Unknown BlockScope flag") } - return c.grammarErrorOnNode(node.AsNode(), diagnostics.X_0_declarations_can_only_be_declared_inside_a_block, keyword) + c.error(node.AsNode(), diagnostics.X_0_declarations_can_only_be_declared_inside_a_block, keyword) } } @@ -1876,7 +1881,17 @@ func (c *Checker) checkGrammarMetaProperty(node *ast.MetaProperty) bool { } case ast.KindImportKeyword: if nameText != "meta" { - return c.grammarErrorOnNode(nodeName, diagnostics.X_0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, nameText, scanner.TokenToString(node.KeywordToken), "meta") + isCallee := ast.IsCallExpression(node.Parent) && node.Parent.AsCallExpression().Expression == node.AsNode() + if nameText == "defer" { + if !isCallee { + return c.grammarErrorAtPos(node.AsNode(), node.AsNode().End(), 0, diagnostics.X_0_expected, "(") + } + } else { + if isCallee { + return c.grammarErrorOnNode(nodeName, diagnostics.X_0_is_not_a_valid_meta_property_for_keyword_import_Did_you_mean_meta_or_defer, nameText) + } + return c.grammarErrorOnNode(nodeName, diagnostics.X_0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, nameText, scanner.TokenToString(node.KeywordToken), "meta") + } } } @@ -2140,7 +2155,8 @@ func (c *Checker) checkGrammarNumericLiteral(node *ast.NumericLiteral) { func (c *Checker) checkGrammarBigIntLiteral(node *ast.BigIntLiteral) bool { literalType := ast.IsLiteralTypeNode(node.Parent) || ast.IsPrefixUnaryExpression(node.Parent) && ast.IsLiteralTypeNode(node.Parent.Parent) if !literalType { - if c.languageVersion < core.ScriptTargetES2020 { + // Don't error on BigInt literals in ambient contexts + if node.Flags&ast.NodeFlagsAmbient == 0 && c.languageVersion < core.ScriptTargetES2020 { if c.grammarErrorOnNode(node.AsNode(), diagnostics.BigInt_literals_are_not_available_when_targeting_lower_than_ES2020) { return true } @@ -2150,11 +2166,24 @@ func (c *Checker) checkGrammarBigIntLiteral(node *ast.BigIntLiteral) bool { } func (c *Checker) checkGrammarImportClause(node *ast.ImportClause) bool { - if node.Flags&ast.NodeFlagsJSDoc == 0 && node.IsTypeOnly && node.Name() != nil && node.NamedBindings != nil { - return c.grammarErrorOnNode(&node.Node, diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both) - } - if node.IsTypeOnly && node.NamedBindings != nil && node.NamedBindings.Kind == ast.KindNamedImports { - return c.checkGrammarTypeOnlyNamedImportsOrExports(node.NamedBindings) + switch node.PhaseModifier { + case ast.KindTypeKeyword: + if node.Flags&ast.NodeFlagsJSDoc == 0 && node.Name() != nil && node.NamedBindings != nil { + return c.grammarErrorOnNode(&node.Node, diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both) + } + if node.NamedBindings != nil && node.NamedBindings.Kind == ast.KindNamedImports { + return c.checkGrammarTypeOnlyNamedImportsOrExports(node.NamedBindings) + } + case ast.KindDeferKeyword: + if node.Name() != nil { + return c.grammarErrorOnNode(&node.Node, diagnostics.Default_imports_are_not_allowed_in_a_deferred_import) + } + if node.NamedBindings != nil && node.NamedBindings.Kind == ast.KindNamedImports { + return c.grammarErrorOnNode(&node.Node, diagnostics.Named_imports_are_not_allowed_in_a_deferred_import) + } + if c.moduleKind != core.ModuleKindESNext && c.moduleKind != core.ModuleKindPreserve { + return c.grammarErrorOnNode(&node.Node, diagnostics.Deferred_imports_are_only_supported_when_the_module_flag_is_set_to_esnext_or_preserve) + } } return false } @@ -2191,7 +2220,11 @@ func (c *Checker) checkGrammarImportCallExpression(node *ast.Node) bool { return c.grammarErrorOnNode(node, getVerbatimModuleSyntaxErrorMessage(node)) } - if c.moduleKind == core.ModuleKindES2015 { + if node.Expression().Kind == ast.KindMetaProperty { + if c.moduleKind != core.ModuleKindESNext && c.moduleKind != core.ModuleKindPreserve { + return c.grammarErrorOnNode(node, diagnostics.Deferred_imports_are_only_supported_when_the_module_flag_is_set_to_esnext_or_preserve) + } + } else if c.moduleKind == core.ModuleKindES2015 { return c.grammarErrorOnNode(node, diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node16_node18_node20_or_nodenext) } diff --git a/internal/checker/nodebuilderimpl.go b/internal/checker/nodebuilderimpl.go index 7826dfbc1b..9cad4bb636 100644 --- a/internal/checker/nodebuilderimpl.go +++ b/internal/checker/nodebuilderimpl.go @@ -1367,6 +1367,8 @@ func (b *nodeBuilderImpl) createMappedTypeNodeFromType(t *Type) *ast.TypeNode { } var appropriateConstraintTypeNode *ast.Node var newTypeVariable *ast.Node + templateType := b.ch.getTemplateTypeFromMappedType(t) + typeParameter := b.ch.getTypeParameterFromMappedType(t) // If the mapped type isn't `keyof` constraint-declared, _but_ still has modifiers preserved, and its naive instantiation won't preserve modifiers because its constraint isn't `keyof` constrained, we have work to do needsModifierPreservingWrapper := !b.ch.isMappedTypeWithKeyofConstraintDeclaration(t) && @@ -1374,18 +1376,17 @@ func (b *nodeBuilderImpl) createMappedTypeNodeFromType(t *Type) *ast.TypeNode { b.ctx.flags&nodebuilder.FlagsGenerateNamesForShadowedTypeParams != 0 && !(b.ch.getConstraintTypeFromMappedType(t).flags&TypeFlagsTypeParameter != 0 && b.ch.getConstraintOfTypeParameter(b.ch.getConstraintTypeFromMappedType(t)).flags&TypeFlagsIndex != 0) - cleanup := b.enterNewScope(mapped.declaration.AsNode(), nil, []*Type{b.ch.getTypeParameterFromMappedType(t)}, nil, nil) - defer cleanup() - if b.ch.isMappedTypeWithKeyofConstraintDeclaration(t) { // We have a { [P in keyof T]: X } // We do this to ensure we retain the toplevel keyof-ness of the type which may be lost due to keyof distribution during `getConstraintTypeFromMappedType` if b.ctx.flags&nodebuilder.FlagsGenerateNamesForShadowedTypeParams != 0 && b.isHomomorphicMappedTypeWithNonHomomorphicInstantiation(mapped) { - newParam := b.ch.newTypeParameter( + newConstraintParam := b.ch.newTypeParameter( b.ch.newSymbol(ast.SymbolFlagsTypeParameter, "T"), ) - name := b.typeParameterToName(newParam) + name := b.typeParameterToName(newConstraintParam) + target := t.Target() newTypeVariable = b.f.NewTypeReferenceNode(name.AsNode(), nil) + templateType = b.ch.instantiateType(b.ch.getTemplateTypeFromMappedType(target), newTypeMapper([]*Type{b.ch.getTypeParameterFromMappedType(target), b.ch.getModifiersTypeFromMappedType(target)}, []*Type{typeParameter, newConstraintParam})) } indexTarget := newTypeVariable if indexTarget == nil { @@ -1405,15 +1406,18 @@ func (b *nodeBuilderImpl) createMappedTypeNodeFromType(t *Type) *ast.TypeNode { appropriateConstraintTypeNode = b.typeToTypeNode(b.ch.getConstraintTypeFromMappedType(t)) } - typeParameterNode := b.typeParameterToDeclarationWithConstraint(b.ch.getTypeParameterFromMappedType(t), appropriateConstraintTypeNode) + // nameType and templateType nodes have to be in the new scope + cleanup := b.enterNewScope(mapped.declaration.AsNode(), nil, []*Type{b.ch.getTypeParameterFromMappedType(t)}, nil, nil) + typeParameterNode := b.typeParameterToDeclarationWithConstraint(typeParameter, appropriateConstraintTypeNode) var nameTypeNode *ast.Node if mapped.declaration.NameType != nil { nameTypeNode = b.typeToTypeNode(b.ch.getNameTypeFromMappedType(t)) } templateTypeNode := b.typeToTypeNode(b.ch.removeMissingType( - b.ch.getTemplateTypeFromMappedType(t), + templateType, getMappedTypeModifiers(t)&MappedTypeModifiersIncludeOptional != 0, )) + cleanup() result := b.f.NewMappedTypeNode( readonlyToken, typeParameterNode, @@ -1440,7 +1444,7 @@ func (b *nodeBuilderImpl) createMappedTypeNodeFromType(t *Type) *ast.TypeNode { originalConstraint := b.ch.instantiateType(rawConstraintTypeFromDeclaration, mapped.mapper) var originalConstraintNode *ast.Node - if originalConstraint.flags&TypeFlagsUnknown != 0 { + if originalConstraint.flags&TypeFlagsUnknown == 0 { originalConstraintNode = b.typeToTypeNode(originalConstraint) } @@ -2214,22 +2218,45 @@ func (b *nodeBuilderImpl) addPropertyToElementList(propertySymbol *ast.Symbol, t if propertySymbol.Flags&ast.SymbolFlagsAccessor != 0 { writeType := b.ch.getWriteTypeOfSymbol(propertySymbol) - if propertyType != writeType && !b.ch.isErrorType(propertyType) && !b.ch.isErrorType(writeType) { - getterDeclaration := ast.GetDeclarationOfKind(propertySymbol, ast.KindGetAccessor) - getterSignature := b.ch.getSignatureFromDeclaration(getterDeclaration) - getter := b.signatureToSignatureDeclarationHelper(getterSignature, ast.KindGetAccessor, &SignatureToSignatureDeclarationOptions{ - name: propertyName, - }) - b.setCommentRange(getter, getterDeclaration) - typeElements = append(typeElements, getter) - setterDeclaration := ast.GetDeclarationOfKind(propertySymbol, ast.KindSetAccessor) - setterSignature := b.ch.getSignatureFromDeclaration(setterDeclaration) - setter := b.signatureToSignatureDeclarationHelper(setterSignature, ast.KindSetAccessor, &SignatureToSignatureDeclarationOptions{ - name: propertyName, - }) - b.setCommentRange(setter, setterDeclaration) - typeElements = append(typeElements, setter) - return typeElements + if !b.ch.isErrorType(propertyType) && !b.ch.isErrorType(writeType) { + propDeclaration := ast.GetDeclarationOfKind(propertySymbol, ast.KindPropertyDeclaration) + if propertyType != writeType || propertySymbol.Parent.Flags&ast.SymbolFlagsClass != 0 && propDeclaration == nil { + if getterDeclaration := ast.GetDeclarationOfKind(propertySymbol, ast.KindGetAccessor); getterDeclaration != nil { + getterSignature := b.ch.getSignatureFromDeclaration(getterDeclaration) + getter := b.signatureToSignatureDeclarationHelper(getterSignature, ast.KindGetAccessor, &SignatureToSignatureDeclarationOptions{ + name: propertyName, + }) + b.setCommentRange(getter, getterDeclaration) + typeElements = append(typeElements, getter) + } + if setterDeclaration := ast.GetDeclarationOfKind(propertySymbol, ast.KindSetAccessor); setterDeclaration != nil { + setterSignature := b.ch.getSignatureFromDeclaration(setterDeclaration) + setter := b.signatureToSignatureDeclarationHelper(setterSignature, ast.KindSetAccessor, &SignatureToSignatureDeclarationOptions{ + name: propertyName, + }) + b.setCommentRange(setter, setterDeclaration) + typeElements = append(typeElements, setter) + } + return typeElements + } else if propertySymbol.Parent.Flags&ast.SymbolFlagsClass != 0 && propDeclaration != nil && core.Find(propDeclaration.ModifierNodes(), func(m *ast.Node) bool { + return m.Kind == ast.KindAccessorKeyword + }) != nil { + fakeGetterSignature := b.ch.newSignature(SignatureFlagsNone, nil, nil, nil, nil, propertyType, nil, 0) + fakeGetterDeclaration := b.signatureToSignatureDeclarationHelper(fakeGetterSignature, ast.KindGetAccessor, &SignatureToSignatureDeclarationOptions{ + name: propertyName, + }) + b.setCommentRange(fakeGetterDeclaration, propDeclaration) + typeElements = append(typeElements, fakeGetterDeclaration) + + setterParam := b.ch.newSymbol(ast.SymbolFlagsFunctionScopedVariable, "arg") + b.ch.valueSymbolLinks.Get(setterParam).resolvedType = writeType + fakeSetterSignature := b.ch.newSignature(SignatureFlagsNone, nil, nil, nil, []*ast.Symbol{setterParam}, b.ch.voidType, nil, 0) + fakeSetterDeclaration := b.signatureToSignatureDeclarationHelper(fakeSetterSignature, ast.KindSetAccessor, &SignatureToSignatureDeclarationOptions{ + name: propertyName, + }) + typeElements = append(typeElements, fakeSetterDeclaration) + return typeElements + } } } diff --git a/internal/checker/nodebuilderscopes.go b/internal/checker/nodebuilderscopes.go index dfd084f712..fa35bd7f31 100644 --- a/internal/checker/nodebuilderscopes.go +++ b/internal/checker/nodebuilderscopes.go @@ -24,12 +24,12 @@ func cloneNodeBuilderContext(context *NodeBuilderContext) func() { // export const y: (x: T_1) => T_1 oldMustCreateTypeParameterSymbolList := context.hasCreatedTypeParameterSymbolList oldMustCreateTypeParametersNamesLookups := context.hasCreatedTypeParametersNamesLookups - context.hasCreatedTypeParameterSymbolList = false - context.hasCreatedTypeParametersNamesLookups = false oldTypeParameterNames := context.typeParameterNames oldTypeParameterNamesByText := context.typeParameterNamesByText oldTypeParameterNamesByTextNextNameCount := context.typeParameterNamesByTextNextNameCount oldTypeParameterSymbolList := context.typeParameterSymbolList + context.hasCreatedTypeParameterSymbolList = oldTypeParameterSymbolList != nil + context.hasCreatedTypeParametersNamesLookups = oldTypeParameterNames != nil context.typeParameterNames = maps.Clone(context.typeParameterNames) context.typeParameterNamesByText = maps.Clone(context.typeParameterNamesByText) context.typeParameterNamesByTextNextNameCount = maps.Clone(context.typeParameterNamesByTextNextNameCount) diff --git a/internal/checker/relater.go b/internal/checker/relater.go index c682637f41..4f101352ff 100644 --- a/internal/checker/relater.go +++ b/internal/checker/relater.go @@ -3298,6 +3298,22 @@ func (r *Relater) structuredTypeRelatedToWorker(source *Type, target *Type, repo return result } } + case source.flags&TypeFlagsTemplateLiteral != 0: + if slices.Equal(source.AsTemplateLiteralType().texts, target.AsTemplateLiteralType().texts) { + result = TernaryTrue + for i, sourceType := range source.AsTemplateLiteralType().types { + targetType := target.AsTemplateLiteralType().types[i] + result &= r.isRelatedTo(sourceType, targetType, RecursionFlagsBoth, false /*reportErrors*/) + if result == TernaryFalse { + return result + } + } + return result + } + case source.flags&TypeFlagsStringMapping != 0: + if source.AsStringMappingType().Symbol() == target.AsStringMappingType().Symbol() { + return r.isRelatedTo(source.AsStringMappingType().target, target.AsStringMappingType().target, RecursionFlagsBoth, false /*reportErrors*/) + } } if source.flags&TypeFlagsObject == 0 { return TernaryFalse @@ -4248,6 +4264,10 @@ func (r *Relater) propertyRelatedTo(source *Type, target *Type, sourceProp *ast. func (r *Relater) isPropertySymbolTypeRelated(sourceProp *ast.Symbol, targetProp *ast.Symbol, getTypeOfSourceProperty func(sym *ast.Symbol) *Type, reportErrors bool, intersectionState IntersectionState) Ternary { targetIsOptional := r.c.strictNullChecks && targetProp.CheckFlags&ast.CheckFlagsPartial != 0 effectiveTarget := r.c.addOptionalityEx(r.c.getNonMissingTypeOfSymbol(targetProp), false /*isProperty*/, targetIsOptional) + // source could resolve to `any` and that's not related to `unknown` target under strict subtype relation + if effectiveTarget.flags&core.IfElse(r.relation == r.c.strictSubtypeRelation, TypeFlagsAny, TypeFlagsAnyOrUnknown) != 0 { + return TernaryTrue + } effectiveSource := getTypeOfSourceProperty(sourceProp) return r.isRelatedToEx(effectiveSource, effectiveTarget, RecursionFlagsBoth, reportErrors, nil /*headMessage*/, intersectionState) } diff --git a/internal/fourslash/_scripts/failingTests.txt b/internal/fourslash/_scripts/failingTests.txt index 24d93fb43a..a3851e759e 100644 --- a/internal/fourslash/_scripts/failingTests.txt +++ b/internal/fourslash/_scripts/failingTests.txt @@ -168,13 +168,9 @@ TestDoubleUnderscoreCompletions TestEditJsdocType TestExportDefaultClass TestExportDefaultFunction -TestFindAllReferencesDynamicImport1 -TestFindAllReferencesUmdModuleAsGlobalConst -TestFindAllRefsExportEquals TestFindAllRefsForDefaultExport03 TestFindAllRefsForModule TestFindAllRefsModuleDotExports -TestFindAllRefs_importType_typeofImport TestFindReferencesBindingPatternInJsdocNoCrash1 TestFindReferencesBindingPatternInJsdocNoCrash2 TestGenericCombinatorWithConstraints1 @@ -262,7 +258,6 @@ TestJsdocTypedefTag TestJsdocTypedefTag2 TestJsdocTypedefTagNamespace TestJsdocTypedefTagServices -TestJsxFindAllReferencesOnRuntimeImportWithPaths1 TestLetQuickInfoAndCompletionList TestLocalFunction TestMemberListInReopenedEnum @@ -436,7 +431,6 @@ TestQuickinfoWrongComment TestRecursiveInternalModuleImport TestReferencesForStatementKeywords TestReferencesInEmptyFile -TestReferencesIsAvailableThroughGlobalNoCrash TestRegexDetection TestRenameForAliasingExport02 TestRenameFromNodeModulesDep1 @@ -461,7 +455,6 @@ TestTripleSlashRefPathCompletionExtensionsAllowJSFalse TestTripleSlashRefPathCompletionExtensionsAllowJSTrue TestTripleSlashRefPathCompletionHiddenFile TestTripleSlashRefPathCompletionRootdirs -TestTslibFindAllReferencesOnRuntimeImportWithPaths1 TestTsxCompletion14 TestTsxCompletion15 TestTsxCompletionNonTagLessThan diff --git a/internal/fourslash/tests/documentHighlightImportPath_test.go b/internal/fourslash/tests/documentHighlightImportPath_test.go new file mode 100644 index 0000000000..229d8b5a13 --- /dev/null +++ b/internal/fourslash/tests/documentHighlightImportPath_test.go @@ -0,0 +1,21 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestDocumentHighlightImportPath(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @Filename: /a.ts +export const x = 0; + +// @Filename: /b.ts +import { x } from "[|./a|]";` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineDocumentHighlights(t, nil /*preferences*/, f.Ranges()[0]) +} diff --git a/internal/fourslash/tests/gen/findAllReferencesDynamicImport1_test.go b/internal/fourslash/tests/gen/findAllReferencesDynamicImport1_test.go index a3cbb55949..a6637254e1 100644 --- a/internal/fourslash/tests/gen/findAllReferencesDynamicImport1_test.go +++ b/internal/fourslash/tests/gen/findAllReferencesDynamicImport1_test.go @@ -9,7 +9,7 @@ import ( func TestFindAllReferencesDynamicImport1(t *testing.T) { t.Parallel() - t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") const content = `// @Filename: foo.ts export function foo() { return "foo"; } diff --git a/internal/fourslash/tests/gen/findAllReferencesUmdModuleAsGlobalConst_test.go b/internal/fourslash/tests/gen/findAllReferencesUmdModuleAsGlobalConst_test.go index 2000320574..c0a0b67b70 100644 --- a/internal/fourslash/tests/gen/findAllReferencesUmdModuleAsGlobalConst_test.go +++ b/internal/fourslash/tests/gen/findAllReferencesUmdModuleAsGlobalConst_test.go @@ -9,7 +9,7 @@ import ( func TestFindAllReferencesUmdModuleAsGlobalConst(t *testing.T) { t.Parallel() - t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") const content = `// @Filename: /node_modules/@types/three/three-core.d.ts export class Vector3 { diff --git a/internal/fourslash/tests/gen/findAllRefsExportEquals_test.go b/internal/fourslash/tests/gen/findAllRefsExportEquals_test.go index dfee6a23bf..56070c7f4e 100644 --- a/internal/fourslash/tests/gen/findAllRefsExportEquals_test.go +++ b/internal/fourslash/tests/gen/findAllRefsExportEquals_test.go @@ -9,7 +9,7 @@ import ( func TestFindAllRefsExportEquals(t *testing.T) { t.Parallel() - t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") const content = `// @Filename: /a.ts type /*0*/T = number; diff --git a/internal/fourslash/tests/gen/findAllRefs_importType_typeofImport_test.go b/internal/fourslash/tests/gen/findAllRefs_importType_typeofImport_test.go index 08792f35a8..02e749e266 100644 --- a/internal/fourslash/tests/gen/findAllRefs_importType_typeofImport_test.go +++ b/internal/fourslash/tests/gen/findAllRefs_importType_typeofImport_test.go @@ -9,7 +9,7 @@ import ( func TestFindAllRefs_importType_typeofImport(t *testing.T) { t.Parallel() - t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") const content = `// @Filename: /a.ts export const x = 0; diff --git a/internal/fourslash/tests/gen/jsxFindAllReferencesOnRuntimeImportWithPaths1_test.go b/internal/fourslash/tests/gen/jsxFindAllReferencesOnRuntimeImportWithPaths1_test.go index 21d0c0ed94..83a9c2d649 100644 --- a/internal/fourslash/tests/gen/jsxFindAllReferencesOnRuntimeImportWithPaths1_test.go +++ b/internal/fourslash/tests/gen/jsxFindAllReferencesOnRuntimeImportWithPaths1_test.go @@ -9,7 +9,7 @@ import ( func TestJsxFindAllReferencesOnRuntimeImportWithPaths1(t *testing.T) { t.Parallel() - t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") const content = `// @Filename: project/src/foo.ts import * as x from /**/"@foo/dir/jsx-runtime"; diff --git a/internal/fourslash/tests/gen/referencesIsAvailableThroughGlobalNoCrash_test.go b/internal/fourslash/tests/gen/referencesIsAvailableThroughGlobalNoCrash_test.go index 0ea3c6e347..d7f6558e51 100644 --- a/internal/fourslash/tests/gen/referencesIsAvailableThroughGlobalNoCrash_test.go +++ b/internal/fourslash/tests/gen/referencesIsAvailableThroughGlobalNoCrash_test.go @@ -9,7 +9,7 @@ import ( func TestReferencesIsAvailableThroughGlobalNoCrash(t *testing.T) { t.Parallel() - t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") const content = `// @Filename: /packages/playwright-core/bundles/utils/node_modules/@types/debug/index.d.ts declare var debug: debug.Debug & { debug: debug.Debug; default: debug.Debug }; diff --git a/internal/fourslash/tests/gen/tslibFindAllReferencesOnRuntimeImportWithPaths1_test.go b/internal/fourslash/tests/gen/tslibFindAllReferencesOnRuntimeImportWithPaths1_test.go index 872403577e..0abd8e3240 100644 --- a/internal/fourslash/tests/gen/tslibFindAllReferencesOnRuntimeImportWithPaths1_test.go +++ b/internal/fourslash/tests/gen/tslibFindAllReferencesOnRuntimeImportWithPaths1_test.go @@ -9,7 +9,7 @@ import ( func TestTslibFindAllReferencesOnRuntimeImportWithPaths1(t *testing.T) { t.Parallel() - t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") const content = `// @Filename: project/src/foo.ts import * as x from /**/"tslib"; diff --git a/internal/ls/autoimportfixes.go b/internal/ls/autoimportfixes.go index ca5c05eda4..4aa8104bb1 100644 --- a/internal/ls/autoimportfixes.go +++ b/internal/ls/autoimportfixes.go @@ -63,7 +63,7 @@ func (ct *changeTracker) doAddExistingFix( importClause := clause.AsImportClause() // promoteFromTypeOnly = true if we need to promote the entire original clause from type only - promoteFromTypeOnly := importClause.IsTypeOnly && core.Some(append(namedImports, defaultImport), func(i *Import) bool { + promoteFromTypeOnly := importClause.IsTypeOnly() && core.Some(append(namedImports, defaultImport), func(i *Import) bool { if i == nil { return false } @@ -89,7 +89,7 @@ func (ct *changeTracker) doAddExistingFix( identifier = ct.NodeFactory.NewIdentifier(namedImport.propertyName).AsIdentifier().AsNode() } return ct.NodeFactory.NewImportSpecifier( - (!importClause.IsTypeOnly || promoteFromTypeOnly) && shouldUseTypeOnly(namedImport.addAsTypeOnly, preferences), + (!importClause.IsTypeOnly() || promoteFromTypeOnly) && shouldUseTypeOnly(namedImport.addAsTypeOnly, preferences), identifier, ct.NodeFactory.NewIdentifier(namedImport.name), ) @@ -245,7 +245,7 @@ func (ct *changeTracker) makeImport(defaultImport *ast.IdentifierNode, namedImpo } var importClause *ast.Node if defaultImport != nil || newNamedImports != nil { - importClause = ct.NodeFactory.NewImportClause(isTypeOnly, defaultImport, newNamedImports) + importClause = ct.NodeFactory.NewImportClause(core.IfElse(isTypeOnly, ast.KindTypeKeyword, ast.KindUnknown), defaultImport, newNamedImports) } return ct.NodeFactory.NewImportDeclaration( /*modifiers*/ nil, importClause, moduleSpecifier, nil /*attributes*/) } @@ -300,7 +300,7 @@ func (ct *changeTracker) getNewImports( declaration = ct.NodeFactory.NewImportDeclaration( /*modifiers*/ nil, ct.NodeFactory.NewImportClause( - shouldUseTypeOnly(namespaceLikeImport.addAsTypeOnly, preferences), + /*phaseModifier*/ core.IfElse(shouldUseTypeOnly(namespaceLikeImport.addAsTypeOnly, preferences), ast.KindTypeKeyword, ast.KindUnknown), /*name*/ nil, ct.NodeFactory.NewNamespaceImport(ct.NodeFactory.NewIdentifier(namespaceLikeImport.name)), ), diff --git a/internal/ls/autoimports.go b/internal/ls/autoimports.go index cfec8707e7..b1bb17660e 100644 --- a/internal/ls/autoimports.go +++ b/internal/ls/autoimports.go @@ -941,7 +941,7 @@ func (info *FixAddToExistingImportInfo) getAddToExistingImportFix(isValidTypeOnl namedBindings := importClause.NamedBindings // A type-only import may not have both a default and named imports, so the only way a name can // be added to an existing type-only import is adding a named import to existing named bindings. - if importClause.IsTypeOnly && !(info.importKind == ImportKindNamed && namedBindings != nil) { + if importClause.IsTypeOnly() && !(info.importKind == ImportKindNamed && namedBindings != nil) { return nil } diff --git a/internal/ls/findallreferences.go b/internal/ls/findallreferences.go index 555b103ace..3845bed6d6 100644 --- a/internal/ls/findallreferences.go +++ b/internal/ls/findallreferences.go @@ -621,7 +621,7 @@ func (l *LanguageService) getReferencedSymbolsForNode(ctx context.Context, posit } if moduleSymbol := checker.GetMergedSymbol(resolvedRef.file.Symbol); moduleSymbol != nil { - return getReferencedSymbolsForModule(program, moduleSymbol /*excludeImportTypeOfExportEquals*/, false, sourceFiles, sourceFilesSet) + return getReferencedSymbolsForModule(ctx, program, moduleSymbol /*excludeImportTypeOfExportEquals*/, false, sourceFiles, sourceFilesSet) } // !!! not implemented @@ -669,11 +669,11 @@ func (l *LanguageService) getReferencedSymbolsForNode(ctx context.Context, posit } if symbol.Name == ast.InternalSymbolNameExportEquals { - return getReferencedSymbolsForModule(program, symbol.Parent, false /*excludeImportTypeOfExportEquals*/, sourceFiles, sourceFilesSet) + return getReferencedSymbolsForModule(ctx, program, symbol.Parent, false /*excludeImportTypeOfExportEquals*/, sourceFiles, sourceFilesSet) } moduleReferences := l.getReferencedSymbolsForModuleIfDeclaredBySourceFile(ctx, symbol, program, sourceFiles, checker, options, sourceFilesSet) // !!! cancellationToken - if moduleReferences != nil && symbol.Flags&ast.SymbolFlagsTransient != 0 { + if moduleReferences != nil && symbol.Flags&ast.SymbolFlagsTransient == 0 { return moduleReferences } @@ -696,7 +696,7 @@ func (l *LanguageService) getReferencedSymbolsForModuleIfDeclaredBySourceFile(ct } exportEquals := symbol.Exports.Get(ast.InternalSymbolNameExportEquals) // If exportEquals != nil, we're about to add references to `import("mod")` anyway, so don't double-count them. - moduleReferences := getReferencedSymbolsForModule(program, symbol, exportEquals != nil, sourceFiles, sourceFilesSet) + moduleReferences := getReferencedSymbolsForModule(ctx, program, symbol, exportEquals != nil, sourceFiles, sourceFilesSet) if exportEquals == nil || !sourceFilesSet.Has(moduleSourceFileName) { return moduleReferences } @@ -727,8 +727,7 @@ func getReferencedSymbolsSpecial(node *ast.Node, sourceFiles []*ast.SourceFile) } if ast.IsImportMeta(node.Parent) && node.Parent.Name() == node { - // !!! unimplemented - return nil // getAllReferencesForImportMeta(sourceFiles /*, cancellationToken*/) + return getAllReferencesForImportMeta(sourceFiles) } if node.Kind == ast.KindStaticKeyword && node.Parent.Kind == ast.KindClassStaticBlockDeclaration { @@ -887,6 +886,22 @@ func getReferencesForSuperKeyword(superKeyword *ast.Node) []*SymbolAndEntries { return []*SymbolAndEntries{NewSymbolAndEntries(definitionKindSymbol, nil, searchSpaceNode.Symbol(), references)} } +func getAllReferencesForImportMeta(sourceFiles []*ast.SourceFile) []*SymbolAndEntries { + references := core.FlatMap(sourceFiles, func(sourceFile *ast.SourceFile) []*referenceEntry { + return core.MapNonNil(getPossibleSymbolReferenceNodes(sourceFile, "meta", sourceFile.AsNode()), func(node *ast.Node) *referenceEntry { + parent := node.Parent + if ast.IsImportMeta(parent) { + return newNodeEntry(parent) + } + return nil + }) + }) + if len(references) == 0 { + return nil + } + return []*SymbolAndEntries{{definition: &Definition{Kind: definitionKindKeyword, node: references[0].node}, references: references}} +} + func getAllReferencesForKeyword(sourceFiles []*ast.SourceFile, keywordKind ast.Kind, filterReadOnlyTypeOperator bool) []*SymbolAndEntries { // references is a list of NodeEntry references := core.FlatMap(sourceFiles, func(sourceFile *ast.SourceFile) []*referenceEntry { @@ -958,6 +973,33 @@ func getPossibleSymbolReferencePositions(sourceFile *ast.SourceFile, symbolName return positions } +// findFirstJsxNode recursively searches for the first JSX element, self-closing element, or fragment +func findFirstJsxNode(root *ast.Node) *ast.Node { + var visit func(*ast.Node) *ast.Node + visit = func(node *ast.Node) *ast.Node { + // Check if this is a JSX node we're looking for + switch node.Kind { + case ast.KindJsxElement, ast.KindJsxSelfClosingElement, ast.KindJsxFragment: + return node + } + + // Skip subtree if it doesn't contain JSX + if node.SubtreeFacts()&ast.SubtreeContainsJsx == 0 { + return nil + } + + // Traverse children to find JSX node + var result *ast.Node + node.ForEachChild(func(child *ast.Node) bool { + result = visit(child) + return result != nil // Stop if found + }) + return result + } + + return visit(root) +} + func getReferencesForNonModule(referencedFile *ast.SourceFile, program *compiler.Program) []*referenceEntry { // !!! not implemented return []*referenceEntry{} @@ -975,8 +1017,104 @@ func getMergedAliasedSymbolOfNamespaceExportDeclaration(node *ast.Node, symbol * return nil } -func getReferencedSymbolsForModule(program *compiler.Program, symbol *ast.Symbol, excludeImportTypeOfExportEquals bool, sourceFiles []*ast.SourceFile, sourceFilesSet *collections.Set[string]) []*SymbolAndEntries { - // !!! not implemented +func getReferencedSymbolsForModule(ctx context.Context, program *compiler.Program, symbol *ast.Symbol, excludeImportTypeOfExportEquals bool, sourceFiles []*ast.SourceFile, sourceFilesSet *collections.Set[string]) []*SymbolAndEntries { + debug.Assert(symbol.ValueDeclaration != nil) + + checker, done := program.GetTypeChecker(ctx) + defer done() + + moduleRefs := findModuleReferences(program, sourceFiles, symbol, checker) + references := core.MapNonNil(moduleRefs, func(reference ModuleReference) *referenceEntry { + switch reference.kind { + case ModuleReferenceKindImport: + parent := reference.literal.Parent + if ast.IsLiteralTypeNode(parent) { + importType := parent.Parent + if ast.IsImportTypeNode(importType) { + importTypeNode := importType.AsImportTypeNode() + if excludeImportTypeOfExportEquals && importTypeNode.Qualifier == nil { + return nil + } + } + } + // import("foo") with no qualifier will reference the `export =` of the module, which may be referenced anyway. + return newNodeEntry(reference.literal) + case ModuleReferenceKindImplicit: + // For implicit references (e.g., JSX runtime imports), return the first JSX node, + // the first statement, or the whole file + var rangeNode *ast.Node + + // Skip the JSX search for tslib imports + if reference.literal.Text() != "tslib" { + rangeNode = findFirstJsxNode(reference.referencingFile.AsNode()) + } + + if rangeNode == nil { + if reference.referencingFile.Statements != nil && len(reference.referencingFile.Statements.Nodes) > 0 { + rangeNode = reference.referencingFile.Statements.Nodes[0] + } else { + rangeNode = reference.referencingFile.AsNode() + } + } + return newNodeEntry(rangeNode) + case ModuleReferenceKindReference: + // or + // We can't easily create a proper range entry here without access to LanguageService, + // but we can create a node-based entry pointing to the source file which will be resolved later + return newNodeEntry(reference.referencingFile.AsNode()) + } + return nil + }) + + // Add references to the module declarations themselves + if len(symbol.Declarations) > 0 { + for _, decl := range symbol.Declarations { + switch decl.Kind { + case ast.KindSourceFile: + // Don't include the source file itself. (This may not be ideal behavior, but awkward to include an entire file as a reference.) + continue + case ast.KindModuleDeclaration: + if sourceFilesSet.Has(ast.GetSourceFileOfNode(decl).FileName()) { + references = append(references, newNodeEntry(decl.AsModuleDeclaration().Name())) + } + default: + // This may be merged with something. + debug.Assert(symbol.Flags&ast.SymbolFlagsTransient != 0, "Expected a module symbol to be declared by a SourceFile or ModuleDeclaration.") + } + } + } + + // Handle export equals declarations + exported := symbol.Exports.Get(ast.InternalSymbolNameExportEquals) + if exported != nil && len(exported.Declarations) > 0 { + for _, decl := range exported.Declarations { + sourceFile := ast.GetSourceFileOfNode(decl) + if sourceFilesSet.Has(sourceFile.FileName()) { + var node *ast.Node + // At `module.exports = ...`, reference node is `module` + if ast.IsBinaryExpression(decl) && ast.IsPropertyAccessExpression(decl.AsBinaryExpression().Left) { + node = decl.AsBinaryExpression().Left.AsPropertyAccessExpression().Expression + } else if ast.IsExportAssignment(decl) { + // Find the export keyword + node = findChildOfKind(decl, ast.KindExportKeyword, sourceFile) + debug.Assert(node != nil, "Expected to find export keyword") + } else { + node = ast.GetNameOfDeclaration(decl) + if node == nil { + node = decl + } + } + references = append(references, newNodeEntry(node)) + } + } + } + + if len(references) > 0 { + return []*SymbolAndEntries{{ + definition: &Definition{Kind: definitionKindSymbol, symbol: symbol}, + references: references, + }} + } return nil } @@ -1030,13 +1168,34 @@ func getReferenceAtPosition(sourceFile *ast.SourceFile, position int, program *c } // -- Core algorithm for find all references -- +func getSpecialSearchKind(node *ast.Node) string { + if node == nil { + return "none" + } + switch node.Kind { + case ast.KindConstructor, ast.KindConstructorKeyword: + return "constructor" + case ast.KindIdentifier: + if ast.IsClassLike(node.Parent) { + debug.Assert(node.Parent.Name() == node) + return "class" + } + fallthrough + default: + return "none" + } +} + func getReferencedSymbolsForSymbol(originalSymbol *ast.Symbol, node *ast.Node, sourceFiles []*ast.SourceFile, sourceFilesSet *collections.Set[string], checker *checker.Checker, options refOptions) []*SymbolAndEntries { // Core find-all-references algorithm for a normal symbol. symbol := core.Coalesce(skipPastExportOrImportSpecifierOrUnion(originalSymbol, node, checker /*useLocalSymbolForExportSpecifier*/, !isForRenameWithPrefixAndSuffixText(options)), originalSymbol) // Compute the meaning from the location and the symbol it references - searchMeaning := getIntersectingMeaningFromDeclarations(node, symbol, ast.SemanticMeaningAll) + searchMeaning := ast.SemanticMeaningAll + if options.use != referenceUseRename { + searchMeaning = getIntersectingMeaningFromDeclarations(node, symbol, ast.SemanticMeaningAll) + } state := newState(sourceFiles, sourceFilesSet, node, checker /*, cancellationToken*/, searchMeaning, options) var exportSpecifier *ast.Node @@ -1050,8 +1209,7 @@ func getReferencedSymbolsForSymbol(originalSymbol *ast.Symbol, node *ast.Node, s // state.getReferencesAtExportSpecifier(exportSpecifier.Name(), symbol, exportSpecifier.AsExportSpecifier(), state.createSearch(node, originalSymbol, comingFromUnknown /*comingFrom*/, "", nil), true /*addReferencesHere*/, true /*alwaysGetReferences*/) } else if node != nil && node.Kind == ast.KindDefaultKeyword && symbol.Name == ast.InternalSymbolNameDefault && symbol.Parent != nil { state.addReference(node, symbol, entryKindNone) - // !!! not implemented - // state.searchForImportsOfExport(node, symbol, &ExportInfo{exportingModuleSymbol: symbol.Parent, exportKind: ExportKindDefault}) + state.searchForImportsOfExport(node, symbol, &ExportInfo{exportingModuleSymbol: symbol.Parent, exportKind: ExportKindDefault}) } else { search := state.createSearch(node, symbol, ImpExpKindUnknown /*comingFrom*/, "", state.populateSearchSymbolSet(symbol, node, options.use == referenceUseRename, options.useAliasesForRename, options.implementations)) state.getReferencesInContainerOrFiles(symbol, search) @@ -1080,21 +1238,21 @@ type refSearch struct { includes func(symbol *ast.Symbol) bool } -// type inheritKey struct { -// symbol *ast.Symbol -// parent *ast.Symbol -// } +type inheritKey struct { + symbol *ast.Symbol + parent *ast.Symbol +} type refState struct { sourceFiles []*ast.SourceFile sourceFilesSet *collections.Set[string] - specialSearchKind string // !!! none, constructor, class + specialSearchKind string // "none", "constructor", or "class" checker *checker.Checker // cancellationToken CancellationToken - searchMeaning ast.SemanticMeaning - options refOptions - result []*SymbolAndEntries - // inheritsFromCache map[inheritKey]bool + searchMeaning ast.SemanticMeaning + options refOptions + result []*SymbolAndEntries + inheritsFromCache map[inheritKey]bool seenContainingTypeReferences collections.Set[*ast.Node] // node seen tracker // seenReExportRHS *collections.Set[*ast.Node] // node seen tracker importTracker ImportTracker @@ -1106,11 +1264,11 @@ func newState(sourceFiles []*ast.SourceFile, sourceFilesSet *collections.Set[str return &refState{ sourceFiles: sourceFiles, sourceFilesSet: sourceFilesSet, - specialSearchKind: "none", // !!! other search kinds not implemented + specialSearchKind: getSpecialSearchKind(node), checker: checker, searchMeaning: searchMeaning, options: options, - // inheritsFromCache: map[inheritKey]bool{}, + inheritsFromCache: map[inheritKey]bool{}, // seenReExportRHS: &collections.Set[*ast.Node]{}, symbolToReferences: map[*ast.Symbol]*SymbolAndEntries{}, sourceFileToSeenSymbols: map[*ast.SourceFile]*collections.Set[*ast.Symbol]{}, @@ -1162,7 +1320,6 @@ func (state *refState) createSearch(location *ast.Node, symbol *ast.Symbol, comi } func (state *refState) referenceAdder(searchSymbol *ast.Symbol) func(*ast.Node, entryKind) { - // !!! after find all references is fully implemented, rename this to something like 'getReferenceAdder' symbolAndEntries := state.symbolToReferences[searchSymbol] if symbolAndEntries == nil { symbolAndEntries = NewSymbolAndEntries(definitionKindSymbol, nil, searchSymbol, nil) @@ -1188,6 +1345,120 @@ func (state *refState) addReference(referenceLocation *ast.Node, symbol *ast.Sym } } +func getReferenceEntriesForShorthandPropertyAssignment(node *ast.Node, checker *checker.Checker, addReference func(*ast.Node)) { + refSymbol := checker.GetSymbolAtLocation(node) + if refSymbol == nil || refSymbol.ValueDeclaration == nil { + return + } + shorthandSymbol := checker.GetShorthandAssignmentValueSymbol(refSymbol.ValueDeclaration) + if shorthandSymbol != nil && len(shorthandSymbol.Declarations) > 0 { + for _, declaration := range shorthandSymbol.Declarations { + if getMeaningFromDeclaration(declaration)&ast.SemanticMeaningValue != 0 { + addReference(declaration) + } + } + } +} + +func climbPastPropertyAccess(node *ast.Node) *ast.Node { + if isRightSideOfPropertyAccess(node) { + return node.Parent + } + return node +} + +func isNewExpressionTarget(node *ast.Node) bool { + if node.Parent == nil { + return false + } + return node.Parent.Kind == ast.KindNewExpression && node.Parent.AsNewExpression().Expression == node +} + +func isCallExpressionTarget(node *ast.Node) bool { + if node.Parent == nil { + return false + } + return node.Parent.Kind == ast.KindCallExpression && node.Parent.AsCallExpression().Expression == node +} + +func isMethodOrAccessor(node *ast.Node) bool { + return node.Kind == ast.KindMethodDeclaration || node.Kind == ast.KindGetAccessor || node.Kind == ast.KindSetAccessor +} + +func tryGetClassByExtendingIdentifier(node *ast.Node) *ast.ClassLikeDeclaration { + return ast.TryGetClassExtendingExpressionWithTypeArguments(climbPastPropertyAccess(node).Parent) +} + +func getClassConstructorSymbol(classSymbol *ast.Symbol) *ast.Symbol { + if classSymbol.Members == nil { + return nil + } + return classSymbol.Members.Get(ast.InternalSymbolNameConstructor) +} + +func hasOwnConstructor(classDeclaration *ast.ClassLikeDeclaration) bool { + return getClassConstructorSymbol(classDeclaration.Symbol()) != nil +} + +func findOwnConstructorReferences(classSymbol *ast.Symbol, sourceFile *ast.SourceFile, addNode func(*ast.Node)) { + constructorSymbol := getClassConstructorSymbol(classSymbol) + if constructorSymbol != nil && len(constructorSymbol.Declarations) > 0 { + for _, decl := range constructorSymbol.Declarations { + if decl.Kind == ast.KindConstructor { + if ctrKeyword := findChildOfKind(decl, ast.KindConstructorKeyword, sourceFile); ctrKeyword != nil { + addNode(ctrKeyword) + } + } + } + } + + if classSymbol.Exports != nil { + for _, member := range classSymbol.Exports.Iter() { + decl := member.ValueDeclaration + if decl != nil && decl.Kind == ast.KindMethodDeclaration { + body := decl.Body() + if body != nil { + forEachDescendantOfKind(body, ast.KindThisKeyword, func(thisKeyword *ast.Node) { + if isNewExpressionTarget(thisKeyword) { + addNode(thisKeyword) + } + }) + } + } + } + } +} + +func findSuperConstructorAccesses(classDeclaration *ast.ClassLikeDeclaration, addNode func(*ast.Node)) { + constructorSymbol := getClassConstructorSymbol(classDeclaration.Symbol()) + if constructorSymbol == nil || len(constructorSymbol.Declarations) == 0 { + return + } + + for _, decl := range constructorSymbol.Declarations { + if decl.Kind == ast.KindConstructor { + body := decl.Body() + if body != nil { + forEachDescendantOfKind(body, ast.KindSuperKeyword, func(node *ast.Node) { + if isCallExpressionTarget(node) { + addNode(node) + } + }) + } + } + } +} + +func forEachDescendantOfKind(node *ast.Node, kind ast.Kind, action func(*ast.Node)) { + node.ForEachChild(func(child *ast.Node) bool { + if child.Kind == kind { + action(child) + } + forEachDescendantOfKind(child, kind, action) + return false + }) +} + func (state *refState) addImplementationReferences(refNode *ast.Node, addRef func(*ast.Node)) { // Check if we found a function/propertyAssignment/method with an implementation or initializer if ast.IsDeclarationName(refNode) && isImplementation(refNode.Parent) { @@ -1201,9 +1472,7 @@ func (state *refState) addImplementationReferences(refNode *ast.Node, addRef fun if refNode.Parent.Kind == ast.KindShorthandPropertyAssignment { // Go ahead and dereference the shorthand assignment by going to its definition - - // !!! not implemented - // getReferenceEntriesForShorthandPropertyAssignment(refNode, state.checker, addRef); + getReferenceEntriesForShorthandPropertyAssignment(refNode, state.checker, addRef) } // Check if the node is within an extends or implements clause @@ -1351,11 +1620,9 @@ func (state *refState) getReferencesAtLocation(sourceFile *ast.SourceFile, posit state.addReference(referenceLocation, relatedSymbol, relatedSymbolKind) } case "constructor": - // !!! not implemented - // state.addConstructorReferences(referenceLocation, sourceFile, search) + state.addConstructorReferences(referenceLocation, relatedSymbol, search, addReferencesHere) case "class": - // !!! not implemented - // state.addClassStaticThisReferences(referenceLocation, search) + state.addClassStaticThisReferences(referenceLocation, relatedSymbol, search, addReferencesHere) } // Use the parent symbol if the location is commonjs require syntax on javascript files only. @@ -1372,6 +1639,78 @@ func (state *refState) getReferencesAtLocation(sourceFile *ast.SourceFile, posit state.getImportOrExportReferences(referenceLocation, referenceSymbol, search) } +func (state *refState) addConstructorReferences(referenceLocation *ast.Node, symbol *ast.Symbol, search *refSearch, addReferencesHere bool) { + if isNewExpressionTarget(referenceLocation) && addReferencesHere { + state.addReference(referenceLocation, symbol, entryKindNone) + } + + pusher := func() func(*ast.Node, entryKind) { + return state.referenceAdder(search.symbol) + } + + if ast.IsClassLike(referenceLocation.Parent) { + // This is the class declaration containing the constructor. + sourceFile := ast.GetSourceFileOfNode(referenceLocation) + findOwnConstructorReferences(search.symbol, sourceFile, func(n *ast.Node) { + pusher()(n, entryKindNone) + }) + } else { + // If this class appears in `extends C`, then the extending class' "super" calls are references. + if classExtending := tryGetClassByExtendingIdentifier(referenceLocation); classExtending != nil { + findSuperConstructorAccesses(classExtending, func(n *ast.Node) { + pusher()(n, entryKindNone) + }) + state.findInheritedConstructorReferences(classExtending) + } + } +} + +func (state *refState) addClassStaticThisReferences(referenceLocation *ast.Node, symbol *ast.Symbol, search *refSearch, addReferencesHere bool) { + if addReferencesHere { + state.addReference(referenceLocation, symbol, entryKindNone) + } + + classLike := referenceLocation.Parent + if state.options.use == referenceUseRename || !ast.IsClassLike(classLike) { + return + } + + addRef := state.referenceAdder(search.symbol) + members := classLike.Members() + if members == nil { + return + } + for _, member := range members { + if !(isMethodOrAccessor(member) && ast.HasStaticModifier(member)) { + continue + } + body := member.Body() + if body != nil { + var cb func(*ast.Node) + cb = func(node *ast.Node) { + if node.Kind == ast.KindThisKeyword { + addRef(node, entryKindNone) + } else if !ast.IsFunctionLike(node) && !ast.IsClassLike(node) { + node.ForEachChild(func(child *ast.Node) bool { + cb(child) + return false + }) + } + } + cb(body) + } + } +} + +func (state *refState) findInheritedConstructorReferences(classDeclaration *ast.ClassLikeDeclaration) { + if hasOwnConstructor(classDeclaration) { + return + } + classSymbol := classDeclaration.Symbol() + search := state.createSearch(nil, classSymbol, ImpExpKindUnknown, "", nil) + state.getReferencesInContainerOrFiles(classSymbol, search) +} + func (state *refState) getImportOrExportReferences(referenceLocation *ast.Node, referenceSymbol *ast.Symbol, search *refSearch) { importOrExport := getImportOrExportSymbol(referenceLocation, referenceSymbol, state.checker, search.comingFrom == ImpExpKindExport) if importOrExport == nil { @@ -1521,9 +1860,7 @@ func (state *refState) getRelatedSymbol(search *refSearch, referenceSymbol *ast. }, func(rootSymbol *ast.Symbol) bool { return !(len(search.parents) != 0 && !core.Some(search.parents, func(parent *ast.Symbol) bool { - return false - // !!! not implemented - // return state.explicitlyInheritsFrom(rootSymbol.Parent, parent) + return state.explicitlyInheritsFrom(rootSymbol.Parent, parent) })) }, ) @@ -1675,3 +2012,34 @@ func (state *refState) searchForName(sourceFile *ast.SourceFile, search *refSear state.getReferencesInSourceFile(sourceFile, search, true /*addReferencesHere*/) } } + +func (state *refState) explicitlyInheritsFrom(symbol *ast.Symbol, parent *ast.Symbol) bool { + if symbol == parent { + return true + } + + // Check cache first + key := inheritKey{symbol: symbol, parent: parent} + if cached, ok := state.inheritsFromCache[key]; ok { + return cached + } + + // Set to false initially to prevent infinite recursion + state.inheritsFromCache[key] = false + + if symbol.Declarations == nil { + return false + } + + inherits := core.Some(symbol.Declarations, func(declaration *ast.Node) bool { + superTypeNodes := getAllSuperTypeNodes(declaration) + return core.Some(superTypeNodes, func(typeReference *ast.TypeNode) bool { + typ := state.checker.GetTypeAtLocation(typeReference.AsNode()) + return typ != nil && typ.Symbol() != nil && state.explicitlyInheritsFrom(typ.Symbol(), parent) + }) + }) + + // Update cache with the actual result + state.inheritsFromCache[key] = inherits + return inherits +} diff --git a/internal/ls/importTracker.go b/internal/ls/importTracker.go index ac434e638d..e4a70d62d7 100644 --- a/internal/ls/importTracker.go +++ b/internal/ls/importTracker.go @@ -6,6 +6,7 @@ import ( "github.com/microsoft/typescript-go/internal/ast" "github.com/microsoft/typescript-go/internal/checker" "github.com/microsoft/typescript-go/internal/collections" + "github.com/microsoft/typescript-go/internal/compiler" "github.com/microsoft/typescript-go/internal/core" "github.com/microsoft/typescript-go/internal/debug" ) @@ -42,6 +43,22 @@ type ImportsResult struct { type ImportTracker func(exportSymbol *ast.Symbol, exportInfo *ExportInfo, isForRename bool) *ImportsResult +type ModuleReferenceKind int32 + +const ( + ModuleReferenceKindImport ModuleReferenceKind = iota + ModuleReferenceKindReference + ModuleReferenceKindImplicit +) + +// ModuleReference represents a reference to a module, either via import, , or implicit reference +type ModuleReference struct { + kind ModuleReferenceKind + literal *ast.Node // for import and implicit kinds (StringLiteralLike) + referencingFile *ast.SourceFile + ref *ast.FileReference // for reference kind +} + // Creates the imports map and returns an ImportTracker that uses it. Call this lazily to avoid calling `getDirectImportsMap` unnecessarily. func createImportTracker(sourceFiles []*ast.SourceFile, sourceFilesSet *collections.Set[string], checker *checker.Checker) ImportTracker { allDirectImports := getDirectImportsMap(sourceFiles, checker) @@ -654,3 +671,58 @@ func symbolNameNoDefault(symbol *ast.Symbol) string { } return "" } + +// findModuleReferences finds all references to a module symbol across the given source files. +// This includes import statements, directives, and implicit references (e.g., JSX runtime imports). +func findModuleReferences(program *compiler.Program, sourceFiles []*ast.SourceFile, searchModuleSymbol *ast.Symbol, checker *checker.Checker) []ModuleReference { + refs := []ModuleReference{} + + for _, referencingFile := range sourceFiles { + searchSourceFile := searchModuleSymbol.ValueDeclaration + if searchSourceFile != nil && searchSourceFile.Kind == ast.KindSourceFile { + // Check directives + for _, ref := range referencingFile.ReferencedFiles { + if program.GetSourceFileFromReference(referencingFile, ref) == searchSourceFile.AsSourceFile() { + refs = append(refs, ModuleReference{ + kind: ModuleReferenceKindReference, + referencingFile: referencingFile, + ref: ref, + }) + } + } + + // Check directives + for _, ref := range referencingFile.TypeReferenceDirectives { + referenced := program.GetResolvedTypeReferenceDirectiveFromTypeReferenceDirective(ref, referencingFile) + if referenced != nil && referenced.ResolvedFileName == searchSourceFile.AsSourceFile().FileName() { + refs = append(refs, ModuleReference{ + kind: ModuleReferenceKindReference, + referencingFile: referencingFile, + ref: ref, + }) + } + } + } + + // Check all imports (including require() calls) + forEachImport(referencingFile, func(importDecl *ast.Node, moduleSpecifier *ast.Node) { + moduleSymbol := checker.GetSymbolAtLocation(moduleSpecifier) + if moduleSymbol == searchModuleSymbol { + if ast.NodeIsSynthesized(importDecl) { + refs = append(refs, ModuleReference{ + kind: ModuleReferenceKindImplicit, + literal: moduleSpecifier, + referencingFile: referencingFile, + }) + } else { + refs = append(refs, ModuleReference{ + kind: ModuleReferenceKindImport, + literal: moduleSpecifier, + }) + } + } + }) + } + + return refs +} diff --git a/internal/ls/string_completions.go b/internal/ls/string_completions.go index 0d5573d7dc..a1a3e6d7f8 100644 --- a/internal/ls/string_completions.go +++ b/internal/ls/string_completions.go @@ -375,6 +375,22 @@ func (l *LanguageService) getStringLiteralCompletionEntries( hasIndexSignature: false, }, } + case ast.KindBinaryExpression: + if parent.AsBinaryExpression().OperatorToken.Kind == ast.KindInKeyword { + t := typeChecker.GetTypeAtLocation(parent.AsBinaryExpression().Right) + properties := getPropertiesForCompletion(t, typeChecker) + return &stringLiteralCompletions{ + fromProperties: &completionsFromProperties{ + symbols: core.Filter(properties, func(s *ast.Symbol) bool { + return s.ValueDeclaration == nil || !ast.IsPrivateIdentifierClassElementDeclaration(s.ValueDeclaration) + }), + hasIndexSignature: false, + }, + } + } + return &stringLiteralCompletions{ + fromTypes: fromContextualType(checker.ContextFlagsNone, node, typeChecker), + } default: result := fromContextualType(checker.ContextFlagsCompletions, node, typeChecker) if result != nil { diff --git a/internal/parser/jsdoc.go b/internal/parser/jsdoc.go index f3f7fd6912..db6a24f4d8 100644 --- a/internal/parser/jsdoc.go +++ b/internal/parser/jsdoc.go @@ -829,7 +829,7 @@ func (p *Parser) parseImportTag(start int, tagName *ast.IdentifierNode, margin i identifier = p.parseIdentifier() } - importClause := p.tryParseImportClause(identifier, afterImportTagPos, true /*isTypeOnly*/, true /*skipJSDocLeadingAsterisks*/) + importClause := p.tryParseImportClause(identifier, afterImportTagPos, ast.KindTypeKeyword, true /*skipJSDocLeadingAsterisks*/) moduleSpecifier := p.parseModuleSpecifier() attributes := p.tryParseImportAttributes() diff --git a/internal/parser/parser.go b/internal/parser/parser.go index 3c9ecee716..ef87829bb6 100644 --- a/internal/parser/parser.go +++ b/internal/parser/parser.go @@ -2100,22 +2100,36 @@ func (p *Parser) parseImportDeclarationOrImportEqualsDeclaration(pos int, hasJSD if p.isIdentifier() { identifier = p.parseIdentifier() } - isTypeOnly := false + phaseModifier := ast.KindUnknown if identifier != nil && identifier.AsIdentifier().Text == "type" && (p.token != ast.KindFromKeyword || p.isIdentifier() && p.lookAhead((*Parser).nextTokenIsFromKeywordOrEqualsToken)) && (p.isIdentifier() || p.tokenAfterImportDefinitelyProducesImportDeclaration()) { - isTypeOnly = true + phaseModifier = ast.KindTypeKeyword identifier = nil if p.isIdentifier() { identifier = p.parseIdentifier() } + } else if identifier != nil && identifier.AsIdentifier().Text == "defer" { + var shouldParseAsDeferModifier bool + if p.token == ast.KindFromKeyword { + shouldParseAsDeferModifier = !p.lookAhead((*Parser).nextTokenIsTokenStringLiteral) + } else { + shouldParseAsDeferModifier = p.token != ast.KindCommaToken && p.token != ast.KindEqualsToken + } + if shouldParseAsDeferModifier { + phaseModifier = ast.KindDeferKeyword + identifier = nil + if p.isIdentifier() { + identifier = p.parseIdentifier() + } + } } - if identifier != nil && !p.tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration() { - importEquals := p.checkJSSyntax(p.parseImportEqualsDeclaration(pos, hasJSDoc, modifiers, identifier, isTypeOnly)) + if identifier != nil && !p.tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration() && phaseModifier != ast.KindDeferKeyword { + importEquals := p.checkJSSyntax(p.parseImportEqualsDeclaration(pos, hasJSDoc, modifiers, identifier, phaseModifier == ast.KindTypeKeyword)) p.statementHasAwaitIdentifier = saveHasAwaitIdentifier // Import= declaration is always parsed in an Await context, no need to reparse return importEquals } - importClause := p.tryParseImportClause(identifier, afterImportPos, isTypeOnly, false /*skipJSDocLeadingAsterisks*/) + importClause := p.tryParseImportClause(identifier, afterImportPos, phaseModifier, false /*skipJSDocLeadingAsterisks*/) p.statementHasAwaitIdentifier = saveHasAwaitIdentifier // import clause is always parsed in an Await context moduleSpecifier := p.parseModuleSpecifier() attributes := p.tryParseImportAttributes() @@ -2180,19 +2194,19 @@ func (p *Parser) parseModuleSpecifier() *ast.Expression { return p.parseExpression() } -func (p *Parser) tryParseImportClause(identifier *ast.Node, pos int, isTypeOnly bool, skipJSDocLeadingAsterisks bool) *ast.Node { +func (p *Parser) tryParseImportClause(identifier *ast.Node, pos int, phaseModifier ast.Kind, skipJSDocLeadingAsterisks bool) *ast.Node { // ImportDeclaration: // import ImportClause from ModuleSpecifier ; // import ModuleSpecifier; if identifier != nil || p.token == ast.KindAsteriskToken || p.token == ast.KindOpenBraceToken { - importClause := p.parseImportClause(identifier, pos, isTypeOnly, skipJSDocLeadingAsterisks) + importClause := p.parseImportClause(identifier, pos, phaseModifier, skipJSDocLeadingAsterisks) p.parseExpected(ast.KindFromKeyword) return importClause } return nil } -func (p *Parser) parseImportClause(identifier *ast.Node, pos int, isTypeOnly bool, skipJSDocLeadingAsterisks bool) *ast.Node { +func (p *Parser) parseImportClause(identifier *ast.Node, pos int, phaseModifier ast.Kind, skipJSDocLeadingAsterisks bool) *ast.Node { // ImportClause: // ImportedDefaultBinding // NameSpaceImport @@ -2216,7 +2230,7 @@ func (p *Parser) parseImportClause(identifier *ast.Node, pos int, isTypeOnly boo p.scanner.SetSkipJSDocLeadingAsterisks(false) } } - result := p.finishNode(p.factory.NewImportClause(isTypeOnly, identifier, namedBindings), pos) + result := p.finishNode(p.factory.NewImportClause(phaseModifier, identifier, namedBindings), pos) p.statementHasAwaitIdentifier = saveHasAwaitIdentifier return result } @@ -2887,6 +2901,7 @@ func (p *Parser) parseImportType() *ast.Node { } p.parseExpected(ast.KindColonToken) attributes = p.parseImportAttributes(currentToken, true /*skipKeyword*/) + p.parseOptional(ast.KindCommaToken) if !p.parseExpected(ast.KindCloseBraceToken) { if len(p.diagnostics) != 0 { lastDiagnostic := p.diagnostics[len(p.diagnostics)-1] @@ -4323,6 +4338,7 @@ func (p *Parser) parseArrowFunctionExpressionBody(isAsync bool, allowReturnTypeI } saveContextFlags := p.contextFlags p.setContextFlags(ast.NodeFlagsAwaitContext, isAsync) + p.setContextFlags(ast.NodeFlagsYieldContext, false) node := p.parseAssignmentExpressionOrHigherWorker(allowReturnTypeInArrowFunction) p.contextFlags = saveContextFlags return node @@ -5014,7 +5030,13 @@ func (p *Parser) parseLeftHandSideExpressionOrHigher() *ast.Expression { p.nextToken() // advance past the 'import' p.nextToken() // advance past the dot expression = p.finishNode(p.factory.NewMetaProperty(ast.KindImportKeyword, p.parseIdentifierName()), pos) - p.sourceFlags |= ast.NodeFlagsPossiblyContainsImportMeta + if expression.Text() == "defer" { + if p.token == ast.KindOpenParenToken || p.token == ast.KindLessThanToken { + p.sourceFlags |= ast.NodeFlagsPossiblyContainsDynamicImport + } + } else { + p.sourceFlags |= ast.NodeFlagsPossiblyContainsImportMeta + } } else { expression = p.parseMemberExpressionOrHigher() } @@ -5877,7 +5899,7 @@ func (p *Parser) isStartOfStatement() bool { case ast.KindConstKeyword, ast.KindExportKeyword: return p.isStartOfDeclaration() case ast.KindAsyncKeyword, ast.KindDeclareKeyword, ast.KindInterfaceKeyword, ast.KindModuleKeyword, ast.KindNamespaceKeyword, - ast.KindTypeKeyword, ast.KindGlobalKeyword: + ast.KindTypeKeyword, ast.KindGlobalKeyword, ast.KindDeferKeyword: // When these don't start a declaration, they're an identifier in an expression statement return true case ast.KindAccessorKeyword, ast.KindPublicKeyword, ast.KindPrivateKeyword, ast.KindProtectedKeyword, ast.KindStaticKeyword, @@ -5926,7 +5948,7 @@ func (p *Parser) scanStartOfDeclaration() bool { // I {} // // could be legal, it would add complexity for very little gain. - case ast.KindInterfaceKeyword, ast.KindTypeKeyword: + case ast.KindInterfaceKeyword, ast.KindTypeKeyword, ast.KindDeferKeyword: return p.nextTokenIsIdentifierOnSameLine() case ast.KindModuleKeyword, ast.KindNamespaceKeyword: return p.nextTokenIsIdentifierOrStringLiteralOnSameLine() @@ -5949,7 +5971,7 @@ func (p *Parser) scanStartOfDeclaration() bool { return p.token == ast.KindOpenBraceToken || p.token == ast.KindIdentifier || p.token == ast.KindExportKeyword case ast.KindImportKeyword: p.nextToken() - return p.token == ast.KindStringLiteral || p.token == ast.KindAsteriskToken || p.token == ast.KindOpenBraceToken || tokenIsIdentifierOrKeyword(p.token) + return p.token == ast.KindDeferKeyword || p.token == ast.KindStringLiteral || p.token == ast.KindAsteriskToken || p.token == ast.KindOpenBraceToken || tokenIsIdentifierOrKeyword(p.token) case ast.KindExportKeyword: p.nextToken() if p.token == ast.KindEqualsToken || p.token == ast.KindAsteriskToken || p.token == ast.KindOpenBraceToken || diff --git a/internal/parser/reparser.go b/internal/parser/reparser.go index 326bbc12e3..446e461985 100644 --- a/internal/parser/reparser.go +++ b/internal/parser/reparser.go @@ -116,7 +116,7 @@ func (p *Parser) reparseUnhosted(tag *ast.Node, parent *ast.Node, jsDoc *ast.Nod break } importClause := p.factory.DeepCloneReparse(importTag.ImportClause) - importClause.AsImportClause().IsTypeOnly = true + importClause.AsImportClause().PhaseModifier = ast.KindTypeKeyword importDeclaration := p.factory.NewJSImportDeclaration( p.factory.DeepCloneReparseModifiers(importTag.Modifiers()), importClause, diff --git a/internal/printer/printer.go b/internal/printer/printer.go index f9581f9e10..6a1c10b6d8 100644 --- a/internal/printer/printer.go +++ b/internal/printer/printer.go @@ -2716,14 +2716,6 @@ func (p *Printer) getBinaryExpressionPrecedence(node *ast.BinaryExpression) (lef case ast.OperatorPrecedenceAssignment: // assignment is right-associative leftPrec = ast.OperatorPrecedenceLeftHandSide - case ast.OperatorPrecedenceCoalesce: - // allow coalesce on the left, but short circuit to BitwiseOR - if isBinaryOperation(node.Left, ast.KindQuestionQuestionToken) { - leftPrec = ast.OperatorPrecedenceCoalesce - } else { - leftPrec = ast.OperatorPrecedenceBitwiseOR - } - rightPrec = ast.OperatorPrecedenceBitwiseOR case ast.OperatorPrecedenceLogicalOR: rightPrec = ast.OperatorPrecedenceLogicalAND case ast.OperatorPrecedenceLogicalAND: @@ -3661,8 +3653,8 @@ func (p *Printer) emitImportDeclaration(node *ast.ImportDeclaration) { func (p *Printer) emitImportClause(node *ast.ImportClause) { state := p.enterNode(node.AsNode()) - if node.IsTypeOnly { - p.emitToken(ast.KindTypeKeyword, node.Pos(), WriteKindKeyword, node.AsNode()) + if node.PhaseModifier != ast.KindUnknown { + p.emitToken(node.PhaseModifier, node.Pos(), WriteKindKeyword, node.AsNode()) p.writeSpace() } if name := node.Name(); name != nil { diff --git a/internal/project/snapshot_test.go b/internal/project/snapshot_test.go index 9ae7aa3366..6578345d52 100644 --- a/internal/project/snapshot_test.go +++ b/internal/project/snapshot_test.go @@ -101,4 +101,23 @@ func TestSnapshot(t *testing.T) { assert.Check(t, snapshotAfter.fs.diskFiles["/home/projects/ts/p1/a.ts"] == nil) assert.Check(t, snapshotAfter.fs.diskFiles["/home/projects/ts/p2/b.ts"] != nil) }) + + t.Run("GetFile returns nil for non-existent files", func(t *testing.T) { + t.Parallel() + files := map[string]any{ + "/home/projects/TS/p1/tsconfig.json": "{}", + "/home/projects/TS/p1/index.ts": "console.log('Hello, world!');", + } + session := setup(files) + session.DidOpenFile(context.Background(), "file:///home/projects/TS/p1/index.ts", 1, files["/home/projects/TS/p1/index.ts"].(string), lsproto.LanguageKindTypeScript) + snapshot, release := session.Snapshot() + defer release() + + handle := snapshot.GetFile("/home/projects/TS/p1/nonexistent.ts") + assert.Check(t, handle == nil, "GetFile should return nil for non-existent file") + + // Test that ReadFile returns false for non-existent file + _, ok := snapshot.ReadFile("/home/projects/TS/p1/nonexistent.ts") + assert.Check(t, !ok, "ReadFile should return false for non-existent file") + }) } diff --git a/internal/project/snapshotfs.go b/internal/project/snapshotfs.go index 9c590cb1fa..b6fe0e6d5e 100644 --- a/internal/project/snapshotfs.go +++ b/internal/project/snapshotfs.go @@ -30,7 +30,7 @@ type SnapshotFS struct { readFiles collections.SyncMap[tspath.Path, memoizedDiskFile] } -type memoizedDiskFile func() *diskFile +type memoizedDiskFile func() FileHandle func (s *SnapshotFS) FS() vfs.FS { return s.fs @@ -43,16 +43,14 @@ func (s *SnapshotFS) GetFile(fileName string) FileHandle { if file, ok := s.diskFiles[s.toPath(fileName)]; ok { return file } - newEntry := memoizedDiskFile(sync.OnceValue(func() *diskFile { + newEntry := memoizedDiskFile(sync.OnceValue(func() FileHandle { if contents, ok := s.fs.ReadFile(fileName); ok { return newDiskFile(fileName, contents) } return nil })) - if entry, ok := s.readFiles.LoadOrStore(s.toPath(fileName), newEntry); ok { - return entry() - } - return nil + entry, _ := s.readFiles.LoadOrStore(s.toPath(fileName), newEntry) + return entry() } type snapshotFSBuilder struct { diff --git a/internal/scanner/scanner.go b/internal/scanner/scanner.go index ec6efc7b01..58bb1d81c8 100644 --- a/internal/scanner/scanner.go +++ b/internal/scanner/scanner.go @@ -51,6 +51,7 @@ var textToKeyword = map[string]ast.Kind{ "debugger": ast.KindDebuggerKeyword, "declare": ast.KindDeclareKeyword, "default": ast.KindDefaultKeyword, + "defer": ast.KindDeferKeyword, "delete": ast.KindDeleteKeyword, "do": ast.KindDoKeyword, "else": ast.KindElseKeyword, diff --git a/internal/testutil/harnessutil/sourcemap_recorder.go b/internal/testutil/harnessutil/sourcemap_recorder.go index c7467f06dd..18e869f8d1 100644 --- a/internal/testutil/harnessutil/sourcemap_recorder.go +++ b/internal/testutil/harnessutil/sourcemap_recorder.go @@ -16,7 +16,7 @@ type writerAggregator struct { strings.Builder } -func (w *writerAggregator) WriteStringF(format string, args ...any) { +func (w *writerAggregator) WriteStringf(format string, args ...any) { w.WriteString(fmt.Sprintf(format, args...)) } @@ -24,8 +24,8 @@ func (w *writerAggregator) WriteLine(s string) { w.WriteString(s + "\r\n") } -func (w *writerAggregator) WriteLineF(format string, args ...any) { - w.WriteStringF(format+"\r\n", args...) +func (w *writerAggregator) WriteLinef(format string, args ...any) { + w.WriteStringf(format+"\r\n", args...) } type sourceMapSpanWithDecodeErrors struct { @@ -103,16 +103,16 @@ func newSourceMapSpanWriter(sourceMapRecorder *writerAggregator, sourceMap *sour } sourceMapRecorder.WriteLine("===================================================================") - sourceMapRecorder.WriteLineF("JsFile: %s", sourceMap.File) - sourceMapRecorder.WriteLineF("mapUrl: %s", sourcemap.TryGetSourceMappingURL(sourcemap.CreateECMALineInfo(jsFile.Content, writer.jsLineMap))) - sourceMapRecorder.WriteLineF("sourceRoot: %s", sourceMap.SourceRoot) - sourceMapRecorder.WriteLineF("sources: %s", strings.Join(sourceMap.Sources, ",")) + sourceMapRecorder.WriteLinef("JsFile: %s", sourceMap.File) + sourceMapRecorder.WriteLinef("mapUrl: %s", sourcemap.TryGetSourceMappingURL(sourcemap.CreateECMALineInfo(jsFile.Content, writer.jsLineMap))) + sourceMapRecorder.WriteLinef("sourceRoot: %s", sourceMap.SourceRoot) + sourceMapRecorder.WriteLinef("sources: %s", strings.Join(sourceMap.Sources, ",")) if len(sourceMap.SourcesContent) > 0 { content, err := json.Marshal(sourceMap.SourcesContent) if err != nil { panic(err) } - sourceMapRecorder.WriteLineF("sourcesContent: %s", content) + sourceMapRecorder.WriteLinef("sourcesContent: %s", content) } sourceMapRecorder.WriteLine("===================================================================") return writer @@ -120,14 +120,14 @@ func newSourceMapSpanWriter(sourceMapRecorder *writerAggregator, sourceMap *sour func (w *sourceMapSpanWriter) getSourceMapSpanString(mapEntry *sourcemap.Mapping, getAbsentNameIndex bool) string { var mapString writerAggregator - mapString.WriteStringF("Emitted(%d, %d)", mapEntry.GeneratedLine+1, mapEntry.GeneratedCharacter+1) + mapString.WriteStringf("Emitted(%d, %d)", mapEntry.GeneratedLine+1, mapEntry.GeneratedCharacter+1) if mapEntry.IsSourceMapping() { - mapString.WriteStringF(" Source(%d, %d) + SourceIndex(%d)", mapEntry.SourceLine+1, mapEntry.SourceCharacter+1, mapEntry.SourceIndex) + mapString.WriteStringf(" Source(%d, %d) + SourceIndex(%d)", mapEntry.SourceLine+1, mapEntry.SourceCharacter+1, mapEntry.SourceIndex) if mapEntry.NameIndex >= 0 && int(mapEntry.NameIndex) < len(w.sourceMapNames) { - mapString.WriteStringF(" name (%s)", w.sourceMapNames[mapEntry.NameIndex]) + mapString.WriteStringf(" name (%s)", w.sourceMapNames[mapEntry.NameIndex]) } else { if mapEntry.NameIndex != sourcemap.MissingName || getAbsentNameIndex { - mapString.WriteStringF(" nameIndex (%d)", mapEntry.NameIndex) + mapString.WriteStringf(" nameIndex (%d)", mapEntry.NameIndex) } } } @@ -180,11 +180,11 @@ func (w *sourceMapSpanWriter) recordNewSourceFileSpan(sourceMapSpan *sourcemap.M w.sourceMapRecorder.WriteLine("-------------------------------------------------------------------") if continuesLine { - w.sourceMapRecorder.WriteLineF("emittedFile:%s (%d, %d)", w.jsFile.UnitName, sourceMapSpan.GeneratedLine+1, sourceMapSpan.GeneratedCharacter+1) + w.sourceMapRecorder.WriteLinef("emittedFile:%s (%d, %d)", w.jsFile.UnitName, sourceMapSpan.GeneratedLine+1, sourceMapSpan.GeneratedCharacter+1) } else { - w.sourceMapRecorder.WriteLineF("emittedFile:%s", w.jsFile.UnitName) + w.sourceMapRecorder.WriteLinef("emittedFile:%s", w.jsFile.UnitName) } - w.sourceMapRecorder.WriteLineF("sourceFile:%s", w.sourceMapSources[w.spansOnSingleLine[0].sourceMapSpan.SourceIndex]) + w.sourceMapRecorder.WriteLinef("sourceFile:%s", w.sourceMapSources[w.spansOnSingleLine[0].sourceMapSpan.SourceIndex]) w.sourceMapRecorder.WriteLine("-------------------------------------------------------------------") w.tsLineMap = core.ComputeECMALineStarts(newSourceFileCode) @@ -198,7 +198,7 @@ func (w *sourceMapSpanWriter) close() { if !w.sourceMapDecoder.hasCompletedDecoding() { w.sourceMapRecorder.WriteLine("!!!! **** There are more source map entries in the sourceMap's mapping than what was encoded") - w.sourceMapRecorder.WriteLineF("!!!! **** Remaining decoded string: %s", w.sourceMapDecoder.getRemainingDecodeString()) + w.sourceMapRecorder.WriteLinef("!!!! **** Remaining decoded string: %s", w.sourceMapDecoder.getRemainingDecodeString()) } // write remaining js lines @@ -223,7 +223,7 @@ func (w *sourceMapSpanWriter) getTextOfLine(line int, lineMap []core.TextPos, co func (w *sourceMapSpanWriter) writeJsFileLines(endJsLine int) { for ; w.nextJsLineToWrite < endJsLine; w.nextJsLineToWrite++ { - w.sourceMapRecorder.WriteStringF(">>>%s", w.getTextOfLine(w.nextJsLineToWrite, w.jsLineMap, w.jsFile.Content)) + w.sourceMapRecorder.WriteStringf(">>>%s", w.getTextOfLine(w.nextJsLineToWrite, w.jsLineMap, w.jsFile.Content)) } } @@ -319,7 +319,7 @@ func (sw *recordedSpanWriter) writeSourceMapSourceText(currentSpan *sourceMapSpa } func (sw *recordedSpanWriter) writeSpanDetails(currentSpan *sourceMapSpanWithDecodeErrors, index int) { - sw.w.sourceMapRecorder.WriteLineF("%s%s", sw.markerIds[index], sw.w.getSourceMapSpanString(currentSpan.sourceMapSpan, false /*getAbsentNameIndex*/)) + sw.w.sourceMapRecorder.WriteLinef("%s%s", sw.markerIds[index], sw.w.getSourceMapSpanString(currentSpan.sourceMapSpan, false /*getAbsentNameIndex*/)) } func (sw *recordedSpanWriter) writeRecordedSpans() { diff --git a/internal/transformers/declarations/transform.go b/internal/transformers/declarations/transform.go index 02bb0d9d41..6217557d5f 100644 --- a/internal/transformers/declarations/transform.go +++ b/internal/transformers/declarations/transform.go @@ -1666,6 +1666,10 @@ func (tx *DeclarationTransformer) transformImportDeclaration(decl *ast.ImportDec tx.tryGetResolutionModeOverride(decl.Attributes), ) } + phaseModifier := decl.ImportClause.AsImportClause().PhaseModifier + if phaseModifier == ast.KindDeferKeyword { + phaseModifier = ast.KindUnknown + } // The `importClause` visibility corresponds to the default's visibility. var visibleDefaultBinding *ast.Node if decl.ImportClause != nil && decl.ImportClause.Name() != nil && tx.resolver.IsDeclarationVisible(decl.ImportClause) { @@ -1681,7 +1685,7 @@ func (tx *DeclarationTransformer) transformImportDeclaration(decl *ast.ImportDec decl.Modifiers(), tx.Factory().UpdateImportClause( decl.ImportClause.AsImportClause(), - decl.ImportClause.AsImportClause().IsTypeOnly, + phaseModifier, visibleDefaultBinding, /*namedBindings*/ nil, ), @@ -1703,7 +1707,7 @@ func (tx *DeclarationTransformer) transformImportDeclaration(decl *ast.ImportDec decl.Modifiers(), tx.Factory().UpdateImportClause( decl.ImportClause.AsImportClause(), - decl.ImportClause.AsImportClause().IsTypeOnly, + phaseModifier, visibleDefaultBinding, namedBindings, ), @@ -1731,7 +1735,7 @@ func (tx *DeclarationTransformer) transformImportDeclaration(decl *ast.ImportDec decl.Modifiers(), tx.Factory().UpdateImportClause( decl.ImportClause.AsImportClause(), - decl.ImportClause.AsImportClause().IsTypeOnly, + phaseModifier, visibleDefaultBinding, namedImports, ), diff --git a/internal/transformers/jsxtransforms/jsx.go b/internal/transformers/jsxtransforms/jsx.go index 1b8be9984f..3372a23339 100644 --- a/internal/transformers/jsxtransforms/jsx.go +++ b/internal/transformers/jsxtransforms/jsx.go @@ -235,7 +235,7 @@ func (tx *JSXTransformer) visitSourceFile(file *ast.SourceFile) *ast.Node { for importSource, importSpecifiersMap := range tx.utilizedImplicitRuntimeImports { s := tx.Factory().NewImportDeclaration( nil, - tx.Factory().NewImportClause(false, nil, tx.Factory().NewNamedImports(tx.Factory().NewNodeList(getSortedSpecifiers(importSpecifiersMap)))), + tx.Factory().NewImportClause(ast.KindUnknown, nil, tx.Factory().NewNamedImports(tx.Factory().NewNodeList(getSortedSpecifiers(importSpecifiersMap)))), tx.Factory().NewStringLiteral(importSource), nil, ) diff --git a/internal/transformers/moduletransforms/esmodule.go b/internal/transformers/moduletransforms/esmodule.go index 30338a1951..5d32b40664 100644 --- a/internal/transformers/moduletransforms/esmodule.go +++ b/internal/transformers/moduletransforms/esmodule.go @@ -215,8 +215,8 @@ func (tx *ESModuleTransformer) visitExportDeclaration(node *ast.ExportDeclaratio importDecl := tx.Factory().NewImportDeclaration( nil, /*modifiers*/ tx.Factory().NewImportClause( - false, /*isTypeOnly*/ - nil, /*name*/ + ast.KindUnknown, /*phaseModifier*/ + nil, /*name*/ tx.Factory().NewNamespaceImport(synthName), ), updatedModuleSpecifier, @@ -308,8 +308,8 @@ func (tx *ESModuleTransformer) createRequireCall(node *ast.Node /*ImportDeclarat importStatement := tx.Factory().NewImportDeclaration( nil, /*modifiers*/ tx.Factory().NewImportClause( - false, /*isTypeOnly*/ - nil, /*name*/ + ast.KindUnknown, /*phaseModifier*/ + nil, /*name*/ tx.Factory().NewNamedImports( tx.Factory().NewNodeList([]*ast.Node{ tx.Factory().NewImportSpecifier( diff --git a/internal/transformers/moduletransforms/externalmoduleinfo.go b/internal/transformers/moduletransforms/externalmoduleinfo.go index 382aa91c62..5e85d015c3 100644 --- a/internal/transformers/moduletransforms/externalmoduleinfo.go +++ b/internal/transformers/moduletransforms/externalmoduleinfo.go @@ -292,7 +292,7 @@ func createExternalHelpersImportDeclarationIfNeeded(emitContext *printer.EmitCon externalHelpersImportDeclaration := emitContext.Factory.NewImportDeclaration( nil, /*modifiers*/ - emitContext.Factory.NewImportClause(false /*isTypeOnly*/, nil /*name*/, namedBindings), + emitContext.Factory.NewImportClause(ast.KindUnknown /*phaseModifier*/, nil /*name*/, namedBindings), emitContext.Factory.NewStringLiteral(externalHelpersModuleNameText), nil, /*attributes*/ ) diff --git a/internal/transformers/tstransforms/importelision.go b/internal/transformers/tstransforms/importelision.go index df2a5e8f06..81d05e0046 100644 --- a/internal/transformers/tstransforms/importelision.go +++ b/internal/transformers/tstransforms/importelision.go @@ -53,7 +53,7 @@ func (tx *ImportElisionTransformer) visit(node *ast.Node) *ast.Node { // all import bindings were elided return nil } - return tx.Factory().UpdateImportClause(n, false /*isTypeOnly*/, name, namedBindings) + return tx.Factory().UpdateImportClause(n, n.PhaseModifier, name, namedBindings) case ast.KindNamespaceImport: if !tx.shouldEmitAliasDeclaration(node) { // elide unused imports diff --git a/internal/transformers/tstransforms/typeeraser.go b/internal/transformers/tstransforms/typeeraser.go index 79528eb344..f2aadbed97 100644 --- a/internal/transformers/tstransforms/typeeraser.go +++ b/internal/transformers/tstransforms/typeeraser.go @@ -269,7 +269,7 @@ func (tx *TypeEraserTransformer) visit(node *ast.Node) *ast.Node { case ast.KindImportClause: n := node.AsImportClause() - if n.IsTypeOnly { + if n.IsTypeOnly() { // Always elide type-only imports return nil } @@ -279,7 +279,7 @@ func (tx *TypeEraserTransformer) visit(node *ast.Node) *ast.Node { // all import bindings were elided return nil } - return tx.Factory().UpdateImportClause(n, false /*isTypeOnly*/, name, namedBindings) + return tx.Factory().UpdateImportClause(n, n.PhaseModifier, name, namedBindings) case ast.KindNamedImports: n := node.AsNamedImports() diff --git a/internal/tsoptions/declscompiler.go b/internal/tsoptions/declscompiler.go index 1b0562c05d..ec730ea048 100644 --- a/internal/tsoptions/declscompiler.go +++ b/internal/tsoptions/declscompiler.go @@ -498,7 +498,7 @@ var optionsForCompiler = []*CommandLineOption{ AffectsProgramStructure: true, Category: diagnostics.Language_and_Environment, Description: diagnostics.Enable_lib_replacement, - DefaultValueDescription: true, + DefaultValueDescription: false, }, // Strict Type Checks diff --git a/internal/tsoptions/enummaps.go b/internal/tsoptions/enummaps.go index 84ac2c5157..6ea4ec4b33 100644 --- a/internal/tsoptions/enummaps.go +++ b/internal/tsoptions/enummaps.go @@ -203,9 +203,9 @@ var moduleDetectionOptionMap = collections.NewOrderedMapFromList([]collections.M var jsxOptionMap = collections.NewOrderedMapFromList([]collections.MapEntry[string, any]{ {Key: "preserve", Value: core.JsxEmitPreserve}, {Key: "react-native", Value: core.JsxEmitReactNative}, - {Key: "react", Value: core.JsxEmitReact}, {Key: "react-jsx", Value: core.JsxEmitReactJSX}, {Key: "react-jsxdev", Value: core.JsxEmitReactJSXDev}, + {Key: "react", Value: core.JsxEmitReact}, }) var InverseJsxOptionMap = collections.NewOrderedMapFromList(func() []collections.MapEntry[core.JsxEmit, string] { diff --git a/package-lock.json b/package-lock.json index 37587ddada..adb5f8575c 100644 --- a/package-lock.json +++ b/package-lock.json @@ -18,13 +18,13 @@ "@types/which": "^3.0.4", "adm-zip": "^0.5.16", "chokidar": "^4.0.3", - "dprint": "^0.50.1", + "dprint": "^0.50.2", "execa": "^9.6.0", "glob": "^10.4.5", "hereby": "^1.11.0", "p-limit": "^6.2.0", "picocolors": "^1.1.1", - "typescript": "^5.9.2", + "typescript": "^5.9.3", "which": "^5.0.0" } }, @@ -36,8 +36,8 @@ }, "devDependencies": { "@types/vscode": "^1.100.0", - "@vscode/vsce": "^3.6.0", - "esbuild": "^0.25.8" + "@vscode/vsce": "^3.6.2", + "esbuild": "^0.25.10" }, "engines": { "vscode": "^1.100.0" @@ -97,13 +97,13 @@ } }, "node_modules/@azure/core-auth": { - "version": "1.10.0", - "resolved": "https://registry.npmjs.org/@azure/core-auth/-/core-auth-1.10.0.tgz", - "integrity": "sha512-88Djs5vBvGbHQHf5ZZcaoNHo6Y8BKZkt3cw2iuJIQzLEgH4Ox6Tm4hjFhbqOxyYsgIG/eJbFEHpxRIfEEWv5Ow==", + "version": "1.10.1", + "resolved": "https://registry.npmjs.org/@azure/core-auth/-/core-auth-1.10.1.tgz", + "integrity": "sha512-ykRMW8PjVAn+RS6ww5cmK9U2CyH9p4Q88YJwvUslfuMmN98w/2rdGRLPqJYObapBCdzBVeDgYWdJnFPFb7qzpg==", "dev": true, "dependencies": { - "@azure/abort-controller": "^2.0.0", - "@azure/core-util": "^1.11.0", + "@azure/abort-controller": "^2.1.2", + "@azure/core-util": "^1.13.0", "tslib": "^2.6.2" }, "engines": { @@ -111,17 +111,17 @@ } }, "node_modules/@azure/core-client": { - "version": "1.10.0", - "resolved": "https://registry.npmjs.org/@azure/core-client/-/core-client-1.10.0.tgz", - "integrity": "sha512-O4aP3CLFNodg8eTHXECaH3B3CjicfzkxVtnrfLkOq0XNP7TIECGfHpK/C6vADZkWP75wzmdBnsIA8ksuJMk18g==", + "version": "1.10.1", + "resolved": "https://registry.npmjs.org/@azure/core-client/-/core-client-1.10.1.tgz", + "integrity": "sha512-Nh5PhEOeY6PrnxNPsEHRr9eimxLwgLlpmguQaHKBinFYA/RU9+kOYVOQqOrTsCL+KSxrLLl1gD8Dk5BFW/7l/w==", "dev": true, "dependencies": { - "@azure/abort-controller": "^2.0.0", - "@azure/core-auth": "^1.4.0", - "@azure/core-rest-pipeline": "^1.20.0", - "@azure/core-tracing": "^1.0.0", - "@azure/core-util": "^1.6.1", - "@azure/logger": "^1.0.0", + "@azure/abort-controller": "^2.1.2", + "@azure/core-auth": "^1.10.0", + "@azure/core-rest-pipeline": "^1.22.0", + "@azure/core-tracing": "^1.3.0", + "@azure/core-util": "^1.13.0", + "@azure/logger": "^1.3.0", "tslib": "^2.6.2" }, "engines": { @@ -129,16 +129,16 @@ } }, "node_modules/@azure/core-rest-pipeline": { - "version": "1.22.0", - "resolved": "https://registry.npmjs.org/@azure/core-rest-pipeline/-/core-rest-pipeline-1.22.0.tgz", - "integrity": "sha512-OKHmb3/Kpm06HypvB3g6Q3zJuvyXcpxDpCS1PnU8OV6AJgSFaee/covXBcPbWc6XDDxtEPlbi3EMQ6nUiPaQtw==", + "version": "1.22.1", + "resolved": "https://registry.npmjs.org/@azure/core-rest-pipeline/-/core-rest-pipeline-1.22.1.tgz", + "integrity": "sha512-UVZlVLfLyz6g3Hy7GNDpooMQonUygH7ghdiSASOOHy97fKj/mPLqgDX7aidOijn+sCMU+WU8NjlPlNTgnvbcGA==", "dev": true, "dependencies": { - "@azure/abort-controller": "^2.0.0", - "@azure/core-auth": "^1.8.0", - "@azure/core-tracing": "^1.0.1", - "@azure/core-util": "^1.11.0", - "@azure/logger": "^1.0.0", + "@azure/abort-controller": "^2.1.2", + "@azure/core-auth": "^1.10.0", + "@azure/core-tracing": "^1.3.0", + "@azure/core-util": "^1.13.0", + "@azure/logger": "^1.3.0", "@typespec/ts-http-runtime": "^0.3.0", "tslib": "^2.6.2" }, @@ -147,9 +147,9 @@ } }, "node_modules/@azure/core-tracing": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/@azure/core-tracing/-/core-tracing-1.3.0.tgz", - "integrity": "sha512-+XvmZLLWPe67WXNZo9Oc9CrPj/Tm8QnHR92fFAFdnbzwNdCH1h+7UdpaQgRSBsMY+oW1kHXNUZQLdZ1gHX3ROw==", + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@azure/core-tracing/-/core-tracing-1.3.1.tgz", + "integrity": "sha512-9MWKevR7Hz8kNzzPLfX4EAtGM2b8mr50HPDBvio96bURP/9C+HjdH3sBlLSNNrvRAr5/k/svoH457gB5IKpmwQ==", "dev": true, "dependencies": { "tslib": "^2.6.2" @@ -159,12 +159,12 @@ } }, "node_modules/@azure/core-util": { - "version": "1.13.0", - "resolved": "https://registry.npmjs.org/@azure/core-util/-/core-util-1.13.0.tgz", - "integrity": "sha512-o0psW8QWQ58fq3i24Q1K2XfS/jYTxr7O1HRcyUE9bV9NttLU+kYOH82Ixj8DGlMTOWgxm1Sss2QAfKK5UkSPxw==", + "version": "1.13.1", + "resolved": "https://registry.npmjs.org/@azure/core-util/-/core-util-1.13.1.tgz", + "integrity": "sha512-XPArKLzsvl0Hf0CaGyKHUyVgF7oDnhKoP85Xv6M4StF/1AhfORhZudHtOyf2s+FcbuQ9dPRAjB8J2KvRRMUK2A==", "dev": true, "dependencies": { - "@azure/abort-controller": "^2.0.0", + "@azure/abort-controller": "^2.1.2", "@typespec/ts-http-runtime": "^0.3.0", "tslib": "^2.6.2" }, @@ -173,9 +173,9 @@ } }, "node_modules/@azure/identity": { - "version": "4.11.1", - "resolved": "https://registry.npmjs.org/@azure/identity/-/identity-4.11.1.tgz", - "integrity": "sha512-0ZdsLRaOyLxtCYgyuqyWqGU5XQ9gGnjxgfoNTt1pvELGkkUFrMATABZFIq8gusM7N1qbqpVtwLOhk0d/3kacLg==", + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/@azure/identity/-/identity-4.12.0.tgz", + "integrity": "sha512-6vuh2R3Cte6SD6azNalLCjIDoryGdcvDVEV7IDRPtm5lHX5ffkDlIalaoOp5YJU08e4ipjJENel20kSMDLAcug==", "dev": true, "dependencies": { "@azure/abort-controller": "^2.0.0", @@ -208,33 +208,33 @@ } }, "node_modules/@azure/msal-browser": { - "version": "4.19.0", - "resolved": "https://registry.npmjs.org/@azure/msal-browser/-/msal-browser-4.19.0.tgz", - "integrity": "sha512-g6Ea+sJmK7l5NUyrPhtD7DNj/tZcsr6VTNNLNuYs8yPvL3HNiIpO/0kzXntF9AqJ/6L+uz9aHmoT1x+RNq6zBQ==", + "version": "4.24.1", + "resolved": "https://registry.npmjs.org/@azure/msal-browser/-/msal-browser-4.24.1.tgz", + "integrity": "sha512-e4sp8ihJIyZQvN0ZM1MMuKlEiiLWUS9V9+kxsVAc6K8MtpXHui8VINmKUxXH0OOksLhFDpdq4sGW1w6uYp431A==", "dev": true, "dependencies": { - "@azure/msal-common": "15.10.0" + "@azure/msal-common": "15.13.0" }, "engines": { "node": ">=0.8.0" } }, "node_modules/@azure/msal-common": { - "version": "15.10.0", - "resolved": "https://registry.npmjs.org/@azure/msal-common/-/msal-common-15.10.0.tgz", - "integrity": "sha512-+cGnma71NV3jzl6DdgdHsqriN4ZA7puBIzObSYCvcIVGMULGb2NrcOGV6IJxO06HoVRHFKijkxd9lcBvS063KQ==", + "version": "15.13.0", + "resolved": "https://registry.npmjs.org/@azure/msal-common/-/msal-common-15.13.0.tgz", + "integrity": "sha512-8oF6nj02qX7eE/6+wFT5NluXRHc05AgdCC3fJnkjiJooq8u7BcLmxaYYSwc2AfEkWRMRi6Eyvvbeqk4U4412Ag==", "dev": true, "engines": { "node": ">=0.8.0" } }, "node_modules/@azure/msal-node": { - "version": "3.7.0", - "resolved": "https://registry.npmjs.org/@azure/msal-node/-/msal-node-3.7.0.tgz", - "integrity": "sha512-WsL11pT0hnoIr/4NCjG6uJswkmNA/9AgEre4mSQZS2e+ZPKUWwUdA5nCTnr4n1FMT1O5ezSEiJushnPW25Y+dA==", + "version": "3.8.0", + "resolved": "https://registry.npmjs.org/@azure/msal-node/-/msal-node-3.8.0.tgz", + "integrity": "sha512-23BXm82Mp5XnRhrcd4mrHa0xuUNRp96ivu3nRatrfdAqjoeWAGyD0eEAafxAOHAEWWmdlyFK4ELFcdziXyw2sA==", "dev": true, "dependencies": { - "@azure/msal-common": "15.10.0", + "@azure/msal-common": "15.13.0", "jsonwebtoken": "^9.0.0", "uuid": "^8.3.0" }, @@ -266,9 +266,9 @@ } }, "node_modules/@dprint/darwin-arm64": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/@dprint/darwin-arm64/-/darwin-arm64-0.50.1.tgz", - "integrity": "sha512-NNKf3dxXn567pd/hpCVLHLbC0dI7s3YvQnUEwjRTOAQVMp6O7/ME+Tg1RPGsDP1IB+Y2fIYSM4qmG02zQrqjAQ==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/@dprint/darwin-arm64/-/darwin-arm64-0.50.2.tgz", + "integrity": "sha512-4d08INZlTxbPW9LK9W8+93viN543/qA2Kxn4azVnPW/xCb2Im03UqJBz8mMm3nJZdtNnK3uTVG3ib1VW+XJisw==", "cpu": [ "arm64" ], @@ -279,9 +279,9 @@ ] }, "node_modules/@dprint/darwin-x64": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/@dprint/darwin-x64/-/darwin-x64-0.50.1.tgz", - "integrity": "sha512-PcY75U3UC/0CLOxWzE0zZJZ2PxzUM5AX2baYL1ovgDGCfqO1H0hINiyxfx/8ncGgPojWBkLs+zrcFiGnXx7BQg==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/@dprint/darwin-x64/-/darwin-x64-0.50.2.tgz", + "integrity": "sha512-ZXWPBwdLojhdBATq+bKwJvB7D8bIzrD6eR/Xuq9UYE7evQazUiR069d9NPF0iVuzTo6wNf9ub9SXI7qDl11EGA==", "cpu": [ "x64" ], @@ -292,9 +292,9 @@ ] }, "node_modules/@dprint/linux-arm64-glibc": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/@dprint/linux-arm64-glibc/-/linux-arm64-glibc-0.50.1.tgz", - "integrity": "sha512-q0TOGy9FsoSKsEQ4sIMKyFweF5M8rW1S5OfwJDNRR2TU2riWByU9TKYIZUzg53iuwYKRypr/kJ5kdbl516afRQ==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/@dprint/linux-arm64-glibc/-/linux-arm64-glibc-0.50.2.tgz", + "integrity": "sha512-marxQzRw8atXAnaawwZHeeUaaAVewrGTlFKKcDASGyjPBhc23J5fHPUPremm8xCbgYZyTlokzrV8/1rDRWhJcw==", "cpu": [ "arm64" ], @@ -305,9 +305,9 @@ ] }, "node_modules/@dprint/linux-arm64-musl": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/@dprint/linux-arm64-musl/-/linux-arm64-musl-0.50.1.tgz", - "integrity": "sha512-XRtxN2cA9rc06WFzzVPDIZYGGLmUXqpVf3F0XhhHV77ikQLJZ5reF4xBOQ+0HjJ/zy8W/HzuGDAHedWyCrRf9g==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/@dprint/linux-arm64-musl/-/linux-arm64-musl-0.50.2.tgz", + "integrity": "sha512-oGDq44ydzo0ZkJk6RHcUzUN5sOMT5HC6WA8kHXI6tkAsLUkaLO2DzZFfW4aAYZUn+hYNpQfQD8iGew0sjkyLyg==", "cpu": [ "arm64" ], @@ -318,9 +318,9 @@ ] }, "node_modules/@dprint/linux-riscv64-glibc": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/@dprint/linux-riscv64-glibc/-/linux-riscv64-glibc-0.50.1.tgz", - "integrity": "sha512-vAk/eYhSjA3LJ/yuYgxkHamiK8+m6YdqVBO/Ka+i16VxyjQyOdcMKBkrLCIqSxgyXd6b8raf9wM59HJbaIpoOg==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/@dprint/linux-riscv64-glibc/-/linux-riscv64-glibc-0.50.2.tgz", + "integrity": "sha512-QMmZoZYWsXezDcC03fBOwPfxhTpPEyHqutcgJ0oauN9QcSXGji9NSZITMmtLz2Ki3T1MIvdaLd1goGzNSvNqTQ==", "cpu": [ "riscv64" ], @@ -331,9 +331,9 @@ ] }, "node_modules/@dprint/linux-x64-glibc": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/@dprint/linux-x64-glibc/-/linux-x64-glibc-0.50.1.tgz", - "integrity": "sha512-EpW5KLekaq4hXmKBWWtfBgZ244S4C+vFmMOd1YaGi8+f0hmPTJzVWLdIgpO2ZwfPQ5iycaVI/JS514PQmXPOvg==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/@dprint/linux-x64-glibc/-/linux-x64-glibc-0.50.2.tgz", + "integrity": "sha512-KMeHEzb4teQJChTgq8HuQzc+reRNDnarOTGTQovAZ9WNjOtKLViftsKWW5HsnRHtP5nUIPE9rF1QLjJ/gUsqvw==", "cpu": [ "x64" ], @@ -344,9 +344,9 @@ ] }, "node_modules/@dprint/linux-x64-musl": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/@dprint/linux-x64-musl/-/linux-x64-musl-0.50.1.tgz", - "integrity": "sha512-assISBbaKKL8LkjrIy/5tpE157MVW6HbyIKAjTtg3tPNM3lDn1oH3twuGtK9WBsN/VoEP3QMZVauolcUJT/VOg==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/@dprint/linux-x64-musl/-/linux-x64-musl-0.50.2.tgz", + "integrity": "sha512-qM37T7H69g5coBTfE7SsA+KZZaRBky6gaUhPgAYxW+fOsoVtZSVkXtfTtQauHTpqqOEtbxfCtum70Hz1fr1teg==", "cpu": [ "x64" ], @@ -357,9 +357,9 @@ ] }, "node_modules/@dprint/win32-arm64": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/@dprint/win32-arm64/-/win32-arm64-0.50.1.tgz", - "integrity": "sha512-ZeaRMQYoFjrsO3lvI1SqzDWDGH1GGXWmNSeXvcFuAf2OgYQJWMBlLotCKiHNJ3uyYneoyhTg2tv9QkApNkZV4Q==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/@dprint/win32-arm64/-/win32-arm64-0.50.2.tgz", + "integrity": "sha512-kuGVHGoxLwssVDsodefUIYQRoO2fQncurH/xKgXiZwMPOSzFcgUzYJQiyqmJEp+PENhO9VT1hXUHZtlyCAWBUQ==", "cpu": [ "arm64" ], @@ -370,9 +370,9 @@ ] }, "node_modules/@dprint/win32-x64": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/@dprint/win32-x64/-/win32-x64-0.50.1.tgz", - "integrity": "sha512-pMm8l/hRZ9zYylKw/yCaYkSV3btYB9UyMDbWqyxNthkQ1gckWrk17VTI6WjwwQuHD4Iaz5JgAYLS36hlUzWkxA==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/@dprint/win32-x64/-/win32-x64-0.50.2.tgz", + "integrity": "sha512-N3l9k31c3IMfVXqL0L6ygIhJFvCIrfQ+Z5Jph6RnCcBO6oDYWeYhAv/qBk1vLsF2y/e79TKsR1tvaEwnrQ03XA==", "cpu": [ "x64" ], @@ -383,9 +383,9 @@ ] }, "node_modules/@esbuild/aix-ppc64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.8.tgz", - "integrity": "sha512-urAvrUedIqEiFR3FYSLTWQgLu5tb+m0qZw0NBEasUeo6wuqatkMDaRT+1uABiGXEu5vqgPd7FGE1BhsAIy9QVA==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.10.tgz", + "integrity": "sha512-0NFWnA+7l41irNuaSVlLfgNT12caWJVLzp5eAVhZ0z1qpxbockccEt3s+149rE64VUI3Ml2zt8Nv5JVc4QXTsw==", "cpu": [ "ppc64" ], @@ -399,9 +399,9 @@ } }, "node_modules/@esbuild/android-arm": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.8.tgz", - "integrity": "sha512-RONsAvGCz5oWyePVnLdZY/HHwA++nxYWIX1atInlaW6SEkwq6XkP3+cb825EUcRs5Vss/lGh/2YxAb5xqc07Uw==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.10.tgz", + "integrity": "sha512-dQAxF1dW1C3zpeCDc5KqIYuZ1tgAdRXNoZP7vkBIRtKZPYe2xVr/d3SkirklCHudW1B45tGiUlz2pUWDfbDD4w==", "cpu": [ "arm" ], @@ -415,9 +415,9 @@ } }, "node_modules/@esbuild/android-arm64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.8.tgz", - "integrity": "sha512-OD3p7LYzWpLhZEyATcTSJ67qB5D+20vbtr6vHlHWSQYhKtzUYrETuWThmzFpZtFsBIxRvhO07+UgVA9m0i/O1w==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.10.tgz", + "integrity": "sha512-LSQa7eDahypv/VO6WKohZGPSJDq5OVOo3UoFR1E4t4Gj1W7zEQMUhI+lo81H+DtB+kP+tDgBp+M4oNCwp6kffg==", "cpu": [ "arm64" ], @@ -431,9 +431,9 @@ } }, "node_modules/@esbuild/android-x64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.8.tgz", - "integrity": "sha512-yJAVPklM5+4+9dTeKwHOaA+LQkmrKFX96BM0A/2zQrbS6ENCmxc4OVoBs5dPkCCak2roAD+jKCdnmOqKszPkjA==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.10.tgz", + "integrity": "sha512-MiC9CWdPrfhibcXwr39p9ha1x0lZJ9KaVfvzA0Wxwz9ETX4v5CHfF09bx935nHlhi+MxhA63dKRRQLiVgSUtEg==", "cpu": [ "x64" ], @@ -447,9 +447,9 @@ } }, "node_modules/@esbuild/darwin-arm64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.8.tgz", - "integrity": "sha512-Jw0mxgIaYX6R8ODrdkLLPwBqHTtYHJSmzzd+QeytSugzQ0Vg4c5rDky5VgkoowbZQahCbsv1rT1KW72MPIkevw==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.10.tgz", + "integrity": "sha512-JC74bdXcQEpW9KkV326WpZZjLguSZ3DfS8wrrvPMHgQOIEIG/sPXEN/V8IssoJhbefLRcRqw6RQH2NnpdprtMA==", "cpu": [ "arm64" ], @@ -463,9 +463,9 @@ } }, "node_modules/@esbuild/darwin-x64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.8.tgz", - "integrity": "sha512-Vh2gLxxHnuoQ+GjPNvDSDRpoBCUzY4Pu0kBqMBDlK4fuWbKgGtmDIeEC081xi26PPjn+1tct+Bh8FjyLlw1Zlg==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.10.tgz", + "integrity": "sha512-tguWg1olF6DGqzws97pKZ8G2L7Ig1vjDmGTwcTuYHbuU6TTjJe5FXbgs5C1BBzHbJ2bo1m3WkQDbWO2PvamRcg==", "cpu": [ "x64" ], @@ -479,9 +479,9 @@ } }, "node_modules/@esbuild/freebsd-arm64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.8.tgz", - "integrity": "sha512-YPJ7hDQ9DnNe5vxOm6jaie9QsTwcKedPvizTVlqWG9GBSq+BuyWEDazlGaDTC5NGU4QJd666V0yqCBL2oWKPfA==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.10.tgz", + "integrity": "sha512-3ZioSQSg1HT2N05YxeJWYR+Libe3bREVSdWhEEgExWaDtyFbbXWb49QgPvFH8u03vUPX10JhJPcz7s9t9+boWg==", "cpu": [ "arm64" ], @@ -495,9 +495,9 @@ } }, "node_modules/@esbuild/freebsd-x64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.8.tgz", - "integrity": "sha512-MmaEXxQRdXNFsRN/KcIimLnSJrk2r5H8v+WVafRWz5xdSVmWLoITZQXcgehI2ZE6gioE6HirAEToM/RvFBeuhw==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.10.tgz", + "integrity": "sha512-LLgJfHJk014Aa4anGDbh8bmI5Lk+QidDmGzuC2D+vP7mv/GeSN+H39zOf7pN5N8p059FcOfs2bVlrRr4SK9WxA==", "cpu": [ "x64" ], @@ -511,9 +511,9 @@ } }, "node_modules/@esbuild/linux-arm": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.8.tgz", - "integrity": "sha512-FuzEP9BixzZohl1kLf76KEVOsxtIBFwCaLupVuk4eFVnOZfU+Wsn+x5Ryam7nILV2pkq2TqQM9EZPsOBuMC+kg==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.10.tgz", + "integrity": "sha512-oR31GtBTFYCqEBALI9r6WxoU/ZofZl962pouZRTEYECvNF/dtXKku8YXcJkhgK/beU+zedXfIzHijSRapJY3vg==", "cpu": [ "arm" ], @@ -527,9 +527,9 @@ } }, "node_modules/@esbuild/linux-arm64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.8.tgz", - "integrity": "sha512-WIgg00ARWv/uYLU7lsuDK00d/hHSfES5BzdWAdAig1ioV5kaFNrtK8EqGcUBJhYqotlUByUKz5Qo6u8tt7iD/w==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.10.tgz", + "integrity": "sha512-5luJWN6YKBsawd5f9i4+c+geYiVEw20FVW5x0v1kEMWNq8UctFjDiMATBxLvmmHA4bf7F6hTRaJgtghFr9iziQ==", "cpu": [ "arm64" ], @@ -543,9 +543,9 @@ } }, "node_modules/@esbuild/linux-ia32": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.8.tgz", - "integrity": "sha512-A1D9YzRX1i+1AJZuFFUMP1E9fMaYY+GnSQil9Tlw05utlE86EKTUA7RjwHDkEitmLYiFsRd9HwKBPEftNdBfjg==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.10.tgz", + "integrity": "sha512-NrSCx2Kim3EnnWgS4Txn0QGt0Xipoumb6z6sUtl5bOEZIVKhzfyp/Lyw4C1DIYvzeW/5mWYPBFJU3a/8Yr75DQ==", "cpu": [ "ia32" ], @@ -559,9 +559,9 @@ } }, "node_modules/@esbuild/linux-loong64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.8.tgz", - "integrity": "sha512-O7k1J/dwHkY1RMVvglFHl1HzutGEFFZ3kNiDMSOyUrB7WcoHGf96Sh+64nTRT26l3GMbCW01Ekh/ThKM5iI7hQ==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.10.tgz", + "integrity": "sha512-xoSphrd4AZda8+rUDDfD9J6FUMjrkTz8itpTITM4/xgerAZZcFW7Dv+sun7333IfKxGG8gAq+3NbfEMJfiY+Eg==", "cpu": [ "loong64" ], @@ -575,9 +575,9 @@ } }, "node_modules/@esbuild/linux-mips64el": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.8.tgz", - "integrity": "sha512-uv+dqfRazte3BzfMp8PAQXmdGHQt2oC/y2ovwpTteqrMx2lwaksiFZ/bdkXJC19ttTvNXBuWH53zy/aTj1FgGw==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.10.tgz", + "integrity": "sha512-ab6eiuCwoMmYDyTnyptoKkVS3k8fy/1Uvq7Dj5czXI6DF2GqD2ToInBI0SHOp5/X1BdZ26RKc5+qjQNGRBelRA==", "cpu": [ "mips64el" ], @@ -591,9 +591,9 @@ } }, "node_modules/@esbuild/linux-ppc64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.8.tgz", - "integrity": "sha512-GyG0KcMi1GBavP5JgAkkstMGyMholMDybAf8wF5A70CALlDM2p/f7YFE7H92eDeH/VBtFJA5MT4nRPDGg4JuzQ==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.10.tgz", + "integrity": "sha512-NLinzzOgZQsGpsTkEbdJTCanwA5/wozN9dSgEl12haXJBzMTpssebuXR42bthOF3z7zXFWH1AmvWunUCkBE4EA==", "cpu": [ "ppc64" ], @@ -607,9 +607,9 @@ } }, "node_modules/@esbuild/linux-riscv64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.8.tgz", - "integrity": "sha512-rAqDYFv3yzMrq7GIcen3XP7TUEG/4LK86LUPMIz6RT8A6pRIDn0sDcvjudVZBiiTcZCY9y2SgYX2lgK3AF+1eg==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.10.tgz", + "integrity": "sha512-FE557XdZDrtX8NMIeA8LBJX3dC2M8VGXwfrQWU7LB5SLOajfJIxmSdyL/gU1m64Zs9CBKvm4UAuBp5aJ8OgnrA==", "cpu": [ "riscv64" ], @@ -623,9 +623,9 @@ } }, "node_modules/@esbuild/linux-s390x": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.8.tgz", - "integrity": "sha512-Xutvh6VjlbcHpsIIbwY8GVRbwoviWT19tFhgdA7DlenLGC/mbc3lBoVb7jxj9Z+eyGqvcnSyIltYUrkKzWqSvg==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.10.tgz", + "integrity": "sha512-3BBSbgzuB9ajLoVZk0mGu+EHlBwkusRmeNYdqmznmMc9zGASFjSsxgkNsqmXugpPk00gJ0JNKh/97nxmjctdew==", "cpu": [ "s390x" ], @@ -639,9 +639,9 @@ } }, "node_modules/@esbuild/linux-x64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.8.tgz", - "integrity": "sha512-ASFQhgY4ElXh3nDcOMTkQero4b1lgubskNlhIfJrsH5OKZXDpUAKBlNS0Kx81jwOBp+HCeZqmoJuihTv57/jvQ==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.10.tgz", + "integrity": "sha512-QSX81KhFoZGwenVyPoberggdW1nrQZSvfVDAIUXr3WqLRZGZqWk/P4T8p2SP+de2Sr5HPcvjhcJzEiulKgnxtA==", "cpu": [ "x64" ], @@ -655,9 +655,9 @@ } }, "node_modules/@esbuild/netbsd-arm64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.8.tgz", - "integrity": "sha512-d1KfruIeohqAi6SA+gENMuObDbEjn22olAR7egqnkCD9DGBG0wsEARotkLgXDu6c4ncgWTZJtN5vcgxzWRMzcw==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.10.tgz", + "integrity": "sha512-AKQM3gfYfSW8XRk8DdMCzaLUFB15dTrZfnX8WXQoOUpUBQ+NaAFCP1kPS/ykbbGYz7rxn0WS48/81l9hFl3u4A==", "cpu": [ "arm64" ], @@ -671,9 +671,9 @@ } }, "node_modules/@esbuild/netbsd-x64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.8.tgz", - "integrity": "sha512-nVDCkrvx2ua+XQNyfrujIG38+YGyuy2Ru9kKVNyh5jAys6n+l44tTtToqHjino2My8VAY6Lw9H7RI73XFi66Cg==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.10.tgz", + "integrity": "sha512-7RTytDPGU6fek/hWuN9qQpeGPBZFfB4zZgcz2VK2Z5VpdUxEI8JKYsg3JfO0n/Z1E/6l05n0unDCNc4HnhQGig==", "cpu": [ "x64" ], @@ -687,9 +687,9 @@ } }, "node_modules/@esbuild/openbsd-arm64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.8.tgz", - "integrity": "sha512-j8HgrDuSJFAujkivSMSfPQSAa5Fxbvk4rgNAS5i3K+r8s1X0p1uOO2Hl2xNsGFppOeHOLAVgYwDVlmxhq5h+SQ==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.10.tgz", + "integrity": "sha512-5Se0VM9Wtq797YFn+dLimf2Zx6McttsH2olUBsDml+lm0GOCRVebRWUvDtkY4BWYv/3NgzS8b/UM3jQNh5hYyw==", "cpu": [ "arm64" ], @@ -703,9 +703,9 @@ } }, "node_modules/@esbuild/openbsd-x64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.8.tgz", - "integrity": "sha512-1h8MUAwa0VhNCDp6Af0HToI2TJFAn1uqT9Al6DJVzdIBAd21m/G0Yfc77KDM3uF3T/YaOgQq3qTJHPbTOInaIQ==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.10.tgz", + "integrity": "sha512-XkA4frq1TLj4bEMB+2HnI0+4RnjbuGZfet2gs/LNs5Hc7D89ZQBHQ0gL2ND6Lzu1+QVkjp3x1gIcPKzRNP8bXw==", "cpu": [ "x64" ], @@ -719,9 +719,9 @@ } }, "node_modules/@esbuild/openharmony-arm64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.8.tgz", - "integrity": "sha512-r2nVa5SIK9tSWd0kJd9HCffnDHKchTGikb//9c7HX+r+wHYCpQrSgxhlY6KWV1nFo1l4KFbsMlHk+L6fekLsUg==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.10.tgz", + "integrity": "sha512-AVTSBhTX8Y/Fz6OmIVBip9tJzZEUcY8WLh7I59+upa5/GPhh2/aM6bvOMQySspnCCHvFi79kMtdJS1w0DXAeag==", "cpu": [ "arm64" ], @@ -734,26 +734,10 @@ "node": ">=18" } }, - "node_modules/@esbuild/sunos-x64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.8.tgz", - "integrity": "sha512-zUlaP2S12YhQ2UzUfcCuMDHQFJyKABkAjvO5YSndMiIkMimPmxA+BYSBikWgsRpvyxuRnow4nS5NPnf9fpv41w==", - "cpu": [ - "x64" - ], - "dev": true, - "optional": true, - "os": [ - "sunos" - ], - "engines": { - "node": ">=18" - } - }, "node_modules/@esbuild/win32-arm64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.8.tgz", - "integrity": "sha512-YEGFFWESlPva8hGL+zvj2z/SaK+pH0SwOM0Nc/d+rVnW7GSTFlLBGzZkuSU9kFIGIo8q9X3ucpZhu8PDN5A2sQ==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.10.tgz", + "integrity": "sha512-ah+9b59KDTSfpaCg6VdJoOQvKjI33nTaQr4UluQwW7aEwZQsbMCfTmfEO4VyewOxx4RaDT/xCy9ra2GPWmO7Kw==", "cpu": [ "arm64" ], @@ -767,9 +751,9 @@ } }, "node_modules/@esbuild/win32-ia32": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.8.tgz", - "integrity": "sha512-hiGgGC6KZ5LZz58OL/+qVVoZiuZlUYlYHNAmczOm7bs2oE1XriPFi5ZHHrS8ACpV5EjySrnoCKmcbQMN+ojnHg==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.10.tgz", + "integrity": "sha512-QHPDbKkrGO8/cz9LKVnJU22HOi4pxZnZhhA2HYHez5Pz4JeffhDjf85E57Oyco163GnzNCVkZK0b/n4Y0UHcSw==", "cpu": [ "ia32" ], @@ -783,9 +767,9 @@ } }, "node_modules/@esbuild/win32-x64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.8.tgz", - "integrity": "sha512-cn3Yr7+OaaZq1c+2pe+8yxC8E144SReCQjN6/2ynubzYjvyqZjTXfQJpAcQpsdJq3My7XADANiYGHoFC69pLQw==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.10.tgz", + "integrity": "sha512-9KpxSVFCu0iK1owoez6aC/s/EdUQLDN3adTxGCqxMVhrPDj6bt5dbrHDXUuq+Bs2vATFBBrQS5vdQ/Ed2P+nbw==", "cpu": [ "x64" ], @@ -954,9 +938,9 @@ } }, "node_modules/@secretlint/formatter/node_modules/chalk": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.5.0.tgz", - "integrity": "sha512-1tm8DTaJhPBG3bIkVeZt1iZM9GfSX2lzOeDVZH9R9ffRHpmHvxZ/QhgQH/aDTkswQVt+YHdXAdS/In/30OjCbg==", + "version": "5.6.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz", + "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==", "dev": true, "engines": { "node": "^12.17.0 || ^14.13 || >=16.0.0" @@ -1061,22 +1045,22 @@ } }, "node_modules/@textlint/ast-node-types": { - "version": "15.2.1", - "resolved": "https://registry.npmjs.org/@textlint/ast-node-types/-/ast-node-types-15.2.1.tgz", - "integrity": "sha512-20fEcLPsXg81yWpApv4FQxrZmlFF/Ta7/kz1HGIL+pJo5cSTmkc+eCki3GpOPZIoZk0tbJU8hrlwUb91F+3SNQ==", + "version": "15.2.2", + "resolved": "https://registry.npmjs.org/@textlint/ast-node-types/-/ast-node-types-15.2.2.tgz", + "integrity": "sha512-9ByYNzWV8tpz6BFaRzeRzIov8dkbSZu9q7IWqEIfmRuLWb2qbI/5gTvKcoWT1HYs4XM7IZ8TKSXcuPvMb6eorA==", "dev": true }, "node_modules/@textlint/linter-formatter": { - "version": "15.2.1", - "resolved": "https://registry.npmjs.org/@textlint/linter-formatter/-/linter-formatter-15.2.1.tgz", - "integrity": "sha512-oollG/BHa07+mMt372amxHohteASC+Zxgollc1sZgiyxo4S6EuureV3a4QIQB0NecA+Ak3d0cl0WI/8nou38jw==", + "version": "15.2.2", + "resolved": "https://registry.npmjs.org/@textlint/linter-formatter/-/linter-formatter-15.2.2.tgz", + "integrity": "sha512-oMVaMJ3exFvXhCj3AqmCbLaeYrTNLqaJnLJMIlmnRM3/kZdxvku4OYdaDzgtlI194cVxamOY5AbHBBVnY79kEg==", "dev": true, "dependencies": { "@azu/format-text": "^1.0.2", "@azu/style-format": "^1.0.1", - "@textlint/module-interop": "15.2.1", - "@textlint/resolver": "15.2.1", - "@textlint/types": "15.2.1", + "@textlint/module-interop": "15.2.2", + "@textlint/resolver": "15.2.2", + "@textlint/types": "15.2.2", "chalk": "^4.1.2", "debug": "^4.4.1", "js-yaml": "^3.14.1", @@ -1206,24 +1190,24 @@ } }, "node_modules/@textlint/module-interop": { - "version": "15.2.1", - "resolved": "https://registry.npmjs.org/@textlint/module-interop/-/module-interop-15.2.1.tgz", - "integrity": "sha512-b/C/ZNrm05n1ypymDknIcpkBle30V2ZgE3JVqQlA9PnQV46Ky510qrZk6s9yfKgA3m1YRnAw04m8xdVtqjq1qg==", + "version": "15.2.2", + "resolved": "https://registry.npmjs.org/@textlint/module-interop/-/module-interop-15.2.2.tgz", + "integrity": "sha512-2rmNcWrcqhuR84Iio1WRzlc4tEoOMHd6T7urjtKNNefpTt1owrTJ9WuOe60yD3FrTW0J/R0ux5wxUbP/eaeFOA==", "dev": true }, "node_modules/@textlint/resolver": { - "version": "15.2.1", - "resolved": "https://registry.npmjs.org/@textlint/resolver/-/resolver-15.2.1.tgz", - "integrity": "sha512-FY3aK4tElEcOJVUsaMj4Zro4jCtKEEwUMIkDL0tcn6ljNcgOF7Em+KskRRk/xowFWayqDtdz5T3u7w/6fjjuJQ==", + "version": "15.2.2", + "resolved": "https://registry.npmjs.org/@textlint/resolver/-/resolver-15.2.2.tgz", + "integrity": "sha512-4hGWjmHt0y+5NAkoYZ8FvEkj8Mez9TqfbTm3BPjoV32cIfEixl2poTOgapn1rfm73905GSO3P1jiWjmgvii13Q==", "dev": true }, "node_modules/@textlint/types": { - "version": "15.2.1", - "resolved": "https://registry.npmjs.org/@textlint/types/-/types-15.2.1.tgz", - "integrity": "sha512-zyqNhSatK1cwxDUgosEEN43hFh3WCty9Zm2Vm3ogU566IYegifwqN54ey/CiRy/DiO4vMcFHykuQnh2Zwp6LLw==", + "version": "15.2.2", + "resolved": "https://registry.npmjs.org/@textlint/types/-/types-15.2.2.tgz", + "integrity": "sha512-X2BHGAR3yXJsCAjwYEDBIk9qUDWcH4pW61ISfmtejau+tVqKtnbbvEZnMTb6mWgKU1BvTmftd5DmB1XVDUtY3g==", "dev": true, "dependencies": { - "@textlint/ast-node-types": "15.2.1" + "@textlint/ast-node-types": "15.2.2" } }, "node_modules/@types/adm-zip": { @@ -1236,12 +1220,12 @@ } }, "node_modules/@types/node": { - "version": "24.2.1", - "resolved": "https://registry.npmjs.org/@types/node/-/node-24.2.1.tgz", - "integrity": "sha512-DRh5K+ka5eJic8CjH7td8QpYEV6Zo10gfRkjHCO3weqZHWDtAaSTFtl4+VMqOJ4N5jcuhZ9/l+yy8rVgw7BQeQ==", + "version": "24.6.1", + "resolved": "https://registry.npmjs.org/@types/node/-/node-24.6.1.tgz", + "integrity": "sha512-ljvjjs3DNXummeIaooB4cLBKg2U6SPI6Hjra/9rRIy7CpM0HpLtG9HptkMKAb4HYWy5S7HUvJEuWgr/y0U8SHw==", "dev": true, "dependencies": { - "undici-types": "~7.10.0" + "undici-types": "~7.13.0" } }, "node_modules/@types/normalize-package-data": { @@ -1257,9 +1241,9 @@ "dev": true }, "node_modules/@types/vscode": { - "version": "1.102.0", - "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.102.0.tgz", - "integrity": "sha512-V9sFXmcXz03FtYTSUsYsu5K0Q9wH9w9V25slddcxrh5JgORD14LpnOA7ov0L9ALi+6HrTjskLJ/tY5zeRF3TFA==", + "version": "1.104.0", + "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.104.0.tgz", + "integrity": "sha512-0KwoU2rZ2ecsTGFxo4K1+f+AErRsYW0fsp6A0zufzGuhyczc2IoKqYqcwXidKXmy2u8YB2GsYsOtiI9Izx3Tig==", "dev": true }, "node_modules/@types/which": { @@ -1279,7 +1263,7 @@ "node_modules/@typescript/libsyncrpc": { "version": "0.0.0", "resolved": "git+ssh://git@github.com/microsoft/libsyncrpc.git#95d8cfcdd52a33169677fbc3b338a745accd7fdb", - "integrity": "sha512-SyPFGguQwJlUExSumvJxI1RnBq0i7KT2bhlBlZhMZfRtSkiGrywps/c+aC9wI2hiOydFGTgnH3vxi7rqiq7Dew==", + "integrity": "sha512-+cxoBpDD+MOdgpnUEIdkxskwV2rKFQwgxHyWTR4mH0ScXbWcRUQGQdP/J7dgVyjXUMZd+eCIY1ism7EdLIyKwg==", "license": "MIT", "engines": { "node": ">= 10.16.0 < 11 || >= 11.8.0 < 12 || >= 12.0.0" @@ -1290,9 +1274,9 @@ "link": true }, "node_modules/@typespec/ts-http-runtime": { - "version": "0.3.0", - "resolved": "https://registry.npmjs.org/@typespec/ts-http-runtime/-/ts-http-runtime-0.3.0.tgz", - "integrity": "sha512-sOx1PKSuFwnIl7z4RN0Ls7N9AQawmR9r66eI5rFCzLDIs8HTIYrIpH9QjYWoX0lkgGrkLxXhi4QnK7MizPRrIg==", + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/@typespec/ts-http-runtime/-/ts-http-runtime-0.3.1.tgz", + "integrity": "sha512-SnbaqayTVFEA6/tYumdF0UmybY0KHyKwGPBXnyckFlrrKdhWFrL3a2HIPXHjht5ZOElKGcXfD2D63P36btb+ww==", "dev": true, "dependencies": { "http-proxy-agent": "^7.0.0", @@ -1304,16 +1288,16 @@ } }, "node_modules/@vscode/vsce": { - "version": "3.6.0", - "resolved": "https://registry.npmjs.org/@vscode/vsce/-/vsce-3.6.0.tgz", - "integrity": "sha512-u2ZoMfymRNJb14aHNawnXJtXHLXDVKc1oKZaH4VELKT/9iWKRVgtQOdwxCgtwSxJoqYvuK4hGlBWQJ05wxADhg==", + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/@vscode/vsce/-/vsce-3.6.2.tgz", + "integrity": "sha512-gvBfarWF+Ii20ESqjA3dpnPJpQJ8fFJYtcWtjwbRADommCzGg1emtmb34E+DKKhECYvaVyAl+TF9lWS/3GSPvg==", "dev": true, "dependencies": { "@azure/identity": "^4.1.0", - "@secretlint/node": "^10.1.1", - "@secretlint/secretlint-formatter-sarif": "^10.1.1", - "@secretlint/secretlint-rule-no-dotenv": "^10.1.1", - "@secretlint/secretlint-rule-preset-recommend": "^10.1.1", + "@secretlint/node": "^10.1.2", + "@secretlint/secretlint-formatter-sarif": "^10.1.2", + "@secretlint/secretlint-rule-no-dotenv": "^10.1.2", + "@secretlint/secretlint-rule-preset-recommend": "^10.1.2", "@vscode/vsce-sign": "^2.0.0", "azure-devops-node-api": "^12.5.0", "chalk": "^4.1.2", @@ -1330,7 +1314,7 @@ "minimatch": "^3.0.3", "parse-semver": "^1.1.1", "read": "^1.0.7", - "secretlint": "^10.1.1", + "secretlint": "^10.1.2", "semver": "^7.5.2", "tmp": "^0.2.3", "typed-rest-client": "^1.8.4", @@ -1350,27 +1334,27 @@ } }, "node_modules/@vscode/vsce-sign": { - "version": "2.0.6", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign/-/vsce-sign-2.0.6.tgz", - "integrity": "sha512-j9Ashk+uOWCDHYDxgGsqzKq5FXW9b9MW7QqOIYZ8IYpneJclWTBeHZz2DJCSKQgo+JAqNcaRRE1hzIx0dswqAw==", + "version": "2.0.8", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign/-/vsce-sign-2.0.8.tgz", + "integrity": "sha512-H7p8E11cZMj6mt8xIi3QXZ7dSU/2MH3Y7c+5JfUhHAV4xfaPNc8ozwLVK282c6ah596KoIJIdPUlNHV7Qs/5JA==", "dev": true, "hasInstallScript": true, "optionalDependencies": { - "@vscode/vsce-sign-alpine-arm64": "2.0.5", - "@vscode/vsce-sign-alpine-x64": "2.0.5", - "@vscode/vsce-sign-darwin-arm64": "2.0.5", - "@vscode/vsce-sign-darwin-x64": "2.0.5", - "@vscode/vsce-sign-linux-arm": "2.0.5", - "@vscode/vsce-sign-linux-arm64": "2.0.5", - "@vscode/vsce-sign-linux-x64": "2.0.5", - "@vscode/vsce-sign-win32-arm64": "2.0.5", - "@vscode/vsce-sign-win32-x64": "2.0.5" + "@vscode/vsce-sign-alpine-arm64": "2.0.6", + "@vscode/vsce-sign-alpine-x64": "2.0.6", + "@vscode/vsce-sign-darwin-arm64": "2.0.2", + "@vscode/vsce-sign-darwin-x64": "2.0.2", + "@vscode/vsce-sign-linux-arm": "2.0.6", + "@vscode/vsce-sign-linux-arm64": "2.0.6", + "@vscode/vsce-sign-linux-x64": "2.0.6", + "@vscode/vsce-sign-win32-arm64": "2.0.6", + "@vscode/vsce-sign-win32-x64": "2.0.6" } }, "node_modules/@vscode/vsce-sign-alpine-arm64": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-alpine-arm64/-/vsce-sign-alpine-arm64-2.0.5.tgz", - "integrity": "sha512-XVmnF40APwRPXSLYA28Ye+qWxB25KhSVpF2eZVtVOs6g7fkpOxsVnpRU1Bz2xG4ySI79IRuapDJoAQFkoOgfdQ==", + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-alpine-arm64/-/vsce-sign-alpine-arm64-2.0.6.tgz", + "integrity": "sha512-wKkJBsvKF+f0GfsUuGT0tSW0kZL87QggEiqNqK6/8hvqsXvpx8OsTEc3mnE1kejkh5r+qUyQ7PtF8jZYN0mo8Q==", "cpu": [ "arm64" ], @@ -1381,9 +1365,9 @@ ] }, "node_modules/@vscode/vsce-sign-alpine-x64": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-alpine-x64/-/vsce-sign-alpine-x64-2.0.5.tgz", - "integrity": "sha512-JuxY3xcquRsOezKq6PEHwCgd1rh1GnhyH6urVEWUzWn1c1PC4EOoyffMD+zLZtFuZF5qR1I0+cqDRNKyPvpK7Q==", + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-alpine-x64/-/vsce-sign-alpine-x64-2.0.6.tgz", + "integrity": "sha512-YoAGlmdK39vKi9jA18i4ufBbd95OqGJxRvF3n6ZbCyziwy3O+JgOpIUPxv5tjeO6gQfx29qBivQ8ZZTUF2Ba0w==", "cpu": [ "x64" ], @@ -1394,9 +1378,9 @@ ] }, "node_modules/@vscode/vsce-sign-darwin-arm64": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-darwin-arm64/-/vsce-sign-darwin-arm64-2.0.5.tgz", - "integrity": "sha512-z2Q62bk0ptADFz8a0vtPvnm6vxpyP3hIEYMU+i1AWz263Pj8Mc38cm/4sjzxu+LIsAfhe9HzvYNS49lV+KsatQ==", + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-darwin-arm64/-/vsce-sign-darwin-arm64-2.0.2.tgz", + "integrity": "sha512-rz8F4pMcxPj8fjKAJIfkUT8ycG9CjIp888VY/6pq6cuI2qEzQ0+b5p3xb74CJnBbSC0p2eRVoe+WgNCAxCLtzQ==", "cpu": [ "arm64" ], @@ -1407,9 +1391,9 @@ ] }, "node_modules/@vscode/vsce-sign-darwin-x64": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-darwin-x64/-/vsce-sign-darwin-x64-2.0.5.tgz", - "integrity": "sha512-ma9JDC7FJ16SuPXlLKkvOD2qLsmW/cKfqK4zzM2iJE1PbckF3BlR08lYqHV89gmuoTpYB55+z8Y5Fz4wEJBVDA==", + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-darwin-x64/-/vsce-sign-darwin-x64-2.0.2.tgz", + "integrity": "sha512-MCjPrQ5MY/QVoZ6n0D92jcRb7eYvxAujG/AH2yM6lI0BspvJQxp0o9s5oiAM9r32r9tkLpiy5s2icsbwefAQIw==", "cpu": [ "x64" ], @@ -1420,9 +1404,9 @@ ] }, "node_modules/@vscode/vsce-sign-linux-arm": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-linux-arm/-/vsce-sign-linux-arm-2.0.5.tgz", - "integrity": "sha512-cdCwtLGmvC1QVrkIsyzv01+o9eR+wodMJUZ9Ak3owhcGxPRB53/WvrDHAFYA6i8Oy232nuen1YqWeEohqBuSzA==", + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-linux-arm/-/vsce-sign-linux-arm-2.0.6.tgz", + "integrity": "sha512-UndEc2Xlq4HsuMPnwu7420uqceXjs4yb5W8E2/UkaHBB9OWCwMd3/bRe/1eLe3D8kPpxzcaeTyXiK3RdzS/1CA==", "cpu": [ "arm" ], @@ -1433,9 +1417,9 @@ ] }, "node_modules/@vscode/vsce-sign-linux-arm64": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-linux-arm64/-/vsce-sign-linux-arm64-2.0.5.tgz", - "integrity": "sha512-Hr1o0veBymg9SmkCqYnfaiUnes5YK6k/lKFA5MhNmiEN5fNqxyPUCdRZMFs3Ajtx2OFW4q3KuYVRwGA7jdLo7Q==", + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-linux-arm64/-/vsce-sign-linux-arm64-2.0.6.tgz", + "integrity": "sha512-cfb1qK7lygtMa4NUl2582nP7aliLYuDEVpAbXJMkDq1qE+olIw/es+C8j1LJwvcRq1I2yWGtSn3EkDp9Dq5FdA==", "cpu": [ "arm64" ], @@ -1446,9 +1430,9 @@ ] }, "node_modules/@vscode/vsce-sign-linux-x64": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-linux-x64/-/vsce-sign-linux-x64-2.0.5.tgz", - "integrity": "sha512-XLT0gfGMcxk6CMRLDkgqEPTyG8Oa0OFe1tPv2RVbphSOjFWJwZgK3TYWx39i/7gqpDHlax0AP6cgMygNJrA6zg==", + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-linux-x64/-/vsce-sign-linux-x64-2.0.6.tgz", + "integrity": "sha512-/olerl1A4sOqdP+hjvJ1sbQjKN07Y3DVnxO4gnbn/ahtQvFrdhUi0G1VsZXDNjfqmXw57DmPi5ASnj/8PGZhAA==", "cpu": [ "x64" ], @@ -1459,9 +1443,9 @@ ] }, "node_modules/@vscode/vsce-sign-win32-arm64": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-win32-arm64/-/vsce-sign-win32-arm64-2.0.5.tgz", - "integrity": "sha512-hco8eaoTcvtmuPhavyCZhrk5QIcLiyAUhEso87ApAWDllG7djIrWiOCtqn48k4pHz+L8oCQlE0nwNHfcYcxOPw==", + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-win32-arm64/-/vsce-sign-win32-arm64-2.0.6.tgz", + "integrity": "sha512-ivM/MiGIY0PJNZBoGtlRBM/xDpwbdlCWomUWuLmIxbi1Cxe/1nooYrEQoaHD8ojVRgzdQEUzMsRbyF5cJJgYOg==", "cpu": [ "arm64" ], @@ -1472,9 +1456,9 @@ ] }, "node_modules/@vscode/vsce-sign-win32-x64": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-win32-x64/-/vsce-sign-win32-x64-2.0.5.tgz", - "integrity": "sha512-1ixKFGM2FwM+6kQS2ojfY3aAelICxjiCzeg4nTHpkeU1Tfs4RC+lVLrgq5NwcBC7ZLr6UfY3Ct3D6suPeOf7BQ==", + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-win32-x64/-/vsce-sign-win32-x64-2.0.6.tgz", + "integrity": "sha512-mgth9Kvze+u8CruYMmhHw6Zgy3GRX2S+Ed5oSokDEK5vPEwGGKnmuXua9tmFhomeAnhgJnL4DCna3TiNuGrBTQ==", "cpu": [ "x64" ], @@ -1606,9 +1590,9 @@ } }, "node_modules/@vscode/vsce/node_modules/lru-cache": { - "version": "11.1.0", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.1.0.tgz", - "integrity": "sha512-QIXZUBJUx+2zHUdQujWejBkcD9+cs94tLn0+YL8UrCh+D5sCXZ4c7LaEH48pNwRY3MLDgqUFyhlCyjJPf1WP0A==", + "version": "11.2.2", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.2.tgz", + "integrity": "sha512-F9ODfyqML2coTIsQpSkRHnLSZMtkU8Q+mSfcaIyKwy58u+8k5nvAYeiNhsyMARvzNcXJ9QfWVrcPsC9e9rAxtg==", "dev": true, "engines": { "node": "20 || >=22" @@ -1689,9 +1673,9 @@ } }, "node_modules/ansi-escapes": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.0.0.tgz", - "integrity": "sha512-GdYO7a61mR0fOlAsvC9/rIHf7L96sBc6dEWzeOu+KAea5bZyQRPIpojrVoI4AXGJS/ycu/fBTdLrUkA4ODrvjw==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.1.1.tgz", + "integrity": "sha512-Zhl0ErHcSRUaVfGUeUdDuLgpkEo8KIFjB4Y9uAc46ScOpdDiU1Dbyplh7qWJeJ/ZHpbyMSM26+X3BySgnIz40Q==", "dev": true, "dependencies": { "environment": "^1.0.0" @@ -1704,9 +1688,9 @@ } }, "node_modules/ansi-regex": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz", - "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==", + "version": "6.2.2", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz", + "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==", "dev": true, "engines": { "node": ">=12" @@ -2147,9 +2131,9 @@ } }, "node_modules/debug": { - "version": "4.4.1", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz", - "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==", + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", "dev": true, "dependencies": { "ms": "^2.1.3" @@ -2238,9 +2222,9 @@ } }, "node_modules/detect-libc": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.4.tgz", - "integrity": "sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA==", + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.1.tgz", + "integrity": "sha512-ecqj/sy1jcK1uWrwpR67UhYrIFQ+5WlGxth34WquCbamhFA6hkkwiu37o6J5xCHdo1oixJRfVRw+ywV+Hq/0Aw==", "dev": true, "optional": true, "engines": { @@ -2303,24 +2287,24 @@ } }, "node_modules/dprint": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/dprint/-/dprint-0.50.1.tgz", - "integrity": "sha512-s+kUyQp2rGpwsM3vVmXySOY3v1NjYyRpKfQZdP4rfNTz6zQuICSO6nqIXNm3YdK1MwNFR/EXSFMuE1YPuulhow==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/dprint/-/dprint-0.50.2.tgz", + "integrity": "sha512-+0Fzg+17jsMMUouK00/Fara5YtGOuE76EAJINHB8VpkXHd0n00rMXtw/03qorOgz23eo8Y0UpYvNZBJJo3aNtw==", "dev": true, "hasInstallScript": true, "bin": { "dprint": "bin.js" }, "optionalDependencies": { - "@dprint/darwin-arm64": "0.50.1", - "@dprint/darwin-x64": "0.50.1", - "@dprint/linux-arm64-glibc": "0.50.1", - "@dprint/linux-arm64-musl": "0.50.1", - "@dprint/linux-riscv64-glibc": "0.50.1", - "@dprint/linux-x64-glibc": "0.50.1", - "@dprint/linux-x64-musl": "0.50.1", - "@dprint/win32-arm64": "0.50.1", - "@dprint/win32-x64": "0.50.1" + "@dprint/darwin-arm64": "0.50.2", + "@dprint/darwin-x64": "0.50.2", + "@dprint/linux-arm64-glibc": "0.50.2", + "@dprint/linux-arm64-musl": "0.50.2", + "@dprint/linux-riscv64-glibc": "0.50.2", + "@dprint/linux-x64-glibc": "0.50.2", + "@dprint/linux-x64-musl": "0.50.2", + "@dprint/win32-arm64": "0.50.2", + "@dprint/win32-x64": "0.50.2" } }, "node_modules/dunder-proto": { @@ -2467,9 +2451,9 @@ } }, "node_modules/esbuild": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.8.tgz", - "integrity": "sha512-vVC0USHGtMi8+R4Kz8rt6JhEWLxsv9Rnu/lGYbPR8u47B+DCBksq9JarW0zOO7bs37hyOK1l2/oqtbciutL5+Q==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.10.tgz", + "integrity": "sha512-9RiGKvCwaqxO2owP61uQ4BgNborAQskMR6QusfWzQqv7AZOg5oGehdY2pRJMTKuwxd1IDBP4rSbI5lHzU7SMsQ==", "dev": true, "hasInstallScript": true, "bin": { @@ -2479,32 +2463,32 @@ "node": ">=18" }, "optionalDependencies": { - "@esbuild/aix-ppc64": "0.25.8", - "@esbuild/android-arm": "0.25.8", - "@esbuild/android-arm64": "0.25.8", - "@esbuild/android-x64": "0.25.8", - "@esbuild/darwin-arm64": "0.25.8", - "@esbuild/darwin-x64": "0.25.8", - "@esbuild/freebsd-arm64": "0.25.8", - "@esbuild/freebsd-x64": "0.25.8", - "@esbuild/linux-arm": "0.25.8", - "@esbuild/linux-arm64": "0.25.8", - "@esbuild/linux-ia32": "0.25.8", - "@esbuild/linux-loong64": "0.25.8", - "@esbuild/linux-mips64el": "0.25.8", - "@esbuild/linux-ppc64": "0.25.8", - "@esbuild/linux-riscv64": "0.25.8", - "@esbuild/linux-s390x": "0.25.8", - "@esbuild/linux-x64": "0.25.8", - "@esbuild/netbsd-arm64": "0.25.8", - "@esbuild/netbsd-x64": "0.25.8", - "@esbuild/openbsd-arm64": "0.25.8", - "@esbuild/openbsd-x64": "0.25.8", - "@esbuild/openharmony-arm64": "0.25.8", - "@esbuild/sunos-x64": "0.25.8", - "@esbuild/win32-arm64": "0.25.8", - "@esbuild/win32-ia32": "0.25.8", - "@esbuild/win32-x64": "0.25.8" + "@esbuild/aix-ppc64": "0.25.10", + "@esbuild/android-arm": "0.25.10", + "@esbuild/android-arm64": "0.25.10", + "@esbuild/android-x64": "0.25.10", + "@esbuild/darwin-arm64": "0.25.10", + "@esbuild/darwin-x64": "0.25.10", + "@esbuild/freebsd-arm64": "0.25.10", + "@esbuild/freebsd-x64": "0.25.10", + "@esbuild/linux-arm": "0.25.10", + "@esbuild/linux-arm64": "0.25.10", + "@esbuild/linux-ia32": "0.25.10", + "@esbuild/linux-loong64": "0.25.10", + "@esbuild/linux-mips64el": "0.25.10", + "@esbuild/linux-ppc64": "0.25.10", + "@esbuild/linux-riscv64": "0.25.10", + "@esbuild/linux-s390x": "0.25.10", + "@esbuild/linux-x64": "0.25.10", + "@esbuild/netbsd-arm64": "0.25.10", + "@esbuild/netbsd-x64": "0.25.10", + "@esbuild/openbsd-arm64": "0.25.10", + "@esbuild/openbsd-x64": "0.25.10", + "@esbuild/openharmony-arm64": "0.25.10", + "@esbuild/sunos-x64": "0.25.10", + "@esbuild/win32-arm64": "0.25.10", + "@esbuild/win32-ia32": "0.25.10", + "@esbuild/win32-x64": "0.25.10" } }, "node_modules/escape-string-regexp": { @@ -2588,9 +2572,9 @@ } }, "node_modules/fast-uri": { - "version": "3.0.6", - "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.0.6.tgz", - "integrity": "sha512-Atfo14OibSv5wAp4VWNsFYE1AchQRTv9cBGWET4pZWHzYshFSS9NQI6I57rdKn9croWVMbYFbLhJ+yJvmZIIHw==", + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.0.tgz", + "integrity": "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==", "dev": true, "funding": [ { @@ -2697,9 +2681,9 @@ "optional": true }, "node_modules/fs-extra": { - "version": "11.3.1", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.1.tgz", - "integrity": "sha512-eXvGGwZ5CL17ZSwHWd3bbgk7UUpF6IFHtP57NYYakPvHOs8GDgDe5KJI36jIJzDkJ6eJjuzRA8eBQb6SkKue0g==", + "version": "11.3.2", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.2.tgz", + "integrity": "sha512-Xr9F6z6up6Ws+NjzMCZc6WXg2YFRlrLP9NQDO3VQrWrfiojdhS56TzueT88ze0uBdCTwEIhQ3ptnmKeWGFAe0A==", "dev": true, "dependencies": { "graceful-fs": "^4.2.0", @@ -3088,9 +3072,9 @@ } }, "node_modules/index-to-position": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/index-to-position/-/index-to-position-1.1.0.tgz", - "integrity": "sha512-XPdx9Dq4t9Qk1mTMbWONJqU7boCoumEH7fRET37HX5+khDUl3J2W6PdALxhILYlIYx2amlwYcRPp28p0tSiojg==", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/index-to-position/-/index-to-position-1.2.0.tgz", + "integrity": "sha512-Yg7+ztRkqslMAS2iFaU+Oa4KTSidr63OsFGlOrJoW981kIYO3CGCS3wA95P1mUi/IVSJkn0D479KTJpVpvFNuw==", "dev": true, "engines": { "node": ">=18" @@ -3635,9 +3619,9 @@ "link": true }, "node_modules/node-abi": { - "version": "3.75.0", - "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.75.0.tgz", - "integrity": "sha512-OhYaY5sDsIka7H7AtijtI9jwGYLyl29eQn/W623DiN/MIv5sUqc4g7BIDThX+gb7di9f6xK02nkp8sdfFWZLTg==", + "version": "3.77.0", + "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.77.0.tgz", + "integrity": "sha512-DSmt0OEcLoK4i3NuscSbGjOf3bqiDEutejqENSplMSFA/gmB8mkED9G4pKWnPl7MDU4rSHebKPHeitpDfyH0cQ==", "dev": true, "optional": true, "dependencies": { @@ -4000,9 +3984,9 @@ } }, "node_modules/pretty-ms": { - "version": "9.2.0", - "resolved": "https://registry.npmjs.org/pretty-ms/-/pretty-ms-9.2.0.tgz", - "integrity": "sha512-4yf0QO/sllf/1zbZWYnvWw3NxCQwLXKzIj0G849LSufP15BXKM0rbD2Z3wVnkMfjdn/CB0Dpp444gYAACdsplg==", + "version": "9.3.0", + "resolved": "https://registry.npmjs.org/pretty-ms/-/pretty-ms-9.3.0.tgz", + "integrity": "sha512-gjVS5hOP+M3wMm5nmNOucbIrqudzs9v/57bWRHQWLYklXqoXKrVfYW2W9+glfGsqtPgpiz5WwyEEB+ksXIx3gQ==", "dev": true, "dependencies": { "parse-ms": "^4.0.0" @@ -4215,9 +4199,9 @@ } }, "node_modules/run-applescript": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.0.0.tgz", - "integrity": "sha512-9by4Ij99JUr/MCFBUkDKLWK3G9HVXmabKz9U5MlIAIuvuzkiOicRYs8XJLxX+xahD+mLiiCYDqF9dKAgtzKP1A==", + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.1.0.tgz", + "integrity": "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==", "dev": true, "engines": { "node": ">=18" @@ -4635,9 +4619,9 @@ } }, "node_modules/strip-ansi": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", - "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.2.tgz", + "integrity": "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==", "dev": true, "dependencies": { "ansi-regex": "^6.0.1" @@ -4824,9 +4808,9 @@ } }, "node_modules/tar-fs": { - "version": "2.1.3", - "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.3.tgz", - "integrity": "sha512-090nwYJDmlhwFwEW3QQl+vaNnxsO2yVsd45eTKRBzSzu+hlb1w2K9inVq5b0ngXuLVqQ4ApvsUHHnu/zQNkWAg==", + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.4.tgz", + "integrity": "sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ==", "dev": true, "optional": true, "dependencies": { @@ -4972,9 +4956,9 @@ } }, "node_modules/typescript": { - "version": "5.9.2", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.2.tgz", - "integrity": "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==", + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", "dev": true, "bin": { "tsc": "bin/tsc", @@ -5006,18 +4990,18 @@ "dev": true }, "node_modules/undici": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/undici/-/undici-7.13.0.tgz", - "integrity": "sha512-l+zSMssRqrzDcb3fjMkjjLGmuiiK2pMIcV++mJaAc9vhjSGpvM7h43QgP+OAMb1GImHmbPyG2tBXeuyG5iY4gA==", + "version": "7.16.0", + "resolved": "https://registry.npmjs.org/undici/-/undici-7.16.0.tgz", + "integrity": "sha512-QEg3HPMll0o3t2ourKwOeUAZ159Kn9mx5pnzHRQO8+Wixmh88YdZRiIwat0iNzNNXn0yoEtXJqFpyW7eM8BV7g==", "dev": true, "engines": { "node": ">=20.18.1" } }, "node_modules/undici-types": { - "version": "7.10.0", - "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.10.0.tgz", - "integrity": "sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag==", + "version": "7.13.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.13.0.tgz", + "integrity": "sha512-Ov2Rr9Sx+fRgagJ5AX0qvItZG/JKKoBRAVITs1zk7IqZGTJUwgUr7qoYBpWwakpWilTZFM98rG/AFRocu10iIQ==", "dev": true }, "node_modules/unicorn-magic": { @@ -5290,9 +5274,9 @@ } }, "node_modules/wrap-ansi/node_modules/ansi-styles": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", - "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", + "version": "6.2.3", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz", + "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==", "dev": true, "engines": { "node": ">=12" @@ -5383,9 +5367,9 @@ } }, "node_modules/yoctocolors": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/yoctocolors/-/yoctocolors-2.1.1.tgz", - "integrity": "sha512-GQHQqAopRhwU8Kt1DDM8NjibDXHC8eoh1erhGAJPEyveY9qqVeXvVikNKrDz69sHowPMorbPUrH/mx8c50eiBQ==", + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/yoctocolors/-/yoctocolors-2.1.2.tgz", + "integrity": "sha512-CzhO+pFNo8ajLM2d2IW/R93ipy99LWjtwblvC1RsoSUMZgyLbYFr221TnSNT7GjGdYui6P459mw9JH/g/zW2ug==", "dev": true, "engines": { "node": ">=18" @@ -5421,70 +5405,70 @@ } }, "@azure/core-auth": { - "version": "1.10.0", - "resolved": "https://registry.npmjs.org/@azure/core-auth/-/core-auth-1.10.0.tgz", - "integrity": "sha512-88Djs5vBvGbHQHf5ZZcaoNHo6Y8BKZkt3cw2iuJIQzLEgH4Ox6Tm4hjFhbqOxyYsgIG/eJbFEHpxRIfEEWv5Ow==", + "version": "1.10.1", + "resolved": "https://registry.npmjs.org/@azure/core-auth/-/core-auth-1.10.1.tgz", + "integrity": "sha512-ykRMW8PjVAn+RS6ww5cmK9U2CyH9p4Q88YJwvUslfuMmN98w/2rdGRLPqJYObapBCdzBVeDgYWdJnFPFb7qzpg==", "dev": true, "requires": { - "@azure/abort-controller": "^2.0.0", - "@azure/core-util": "^1.11.0", + "@azure/abort-controller": "^2.1.2", + "@azure/core-util": "^1.13.0", "tslib": "^2.6.2" } }, "@azure/core-client": { - "version": "1.10.0", - "resolved": "https://registry.npmjs.org/@azure/core-client/-/core-client-1.10.0.tgz", - "integrity": "sha512-O4aP3CLFNodg8eTHXECaH3B3CjicfzkxVtnrfLkOq0XNP7TIECGfHpK/C6vADZkWP75wzmdBnsIA8ksuJMk18g==", + "version": "1.10.1", + "resolved": "https://registry.npmjs.org/@azure/core-client/-/core-client-1.10.1.tgz", + "integrity": "sha512-Nh5PhEOeY6PrnxNPsEHRr9eimxLwgLlpmguQaHKBinFYA/RU9+kOYVOQqOrTsCL+KSxrLLl1gD8Dk5BFW/7l/w==", "dev": true, "requires": { - "@azure/abort-controller": "^2.0.0", - "@azure/core-auth": "^1.4.0", - "@azure/core-rest-pipeline": "^1.20.0", - "@azure/core-tracing": "^1.0.0", - "@azure/core-util": "^1.6.1", - "@azure/logger": "^1.0.0", + "@azure/abort-controller": "^2.1.2", + "@azure/core-auth": "^1.10.0", + "@azure/core-rest-pipeline": "^1.22.0", + "@azure/core-tracing": "^1.3.0", + "@azure/core-util": "^1.13.0", + "@azure/logger": "^1.3.0", "tslib": "^2.6.2" } }, "@azure/core-rest-pipeline": { - "version": "1.22.0", - "resolved": "https://registry.npmjs.org/@azure/core-rest-pipeline/-/core-rest-pipeline-1.22.0.tgz", - "integrity": "sha512-OKHmb3/Kpm06HypvB3g6Q3zJuvyXcpxDpCS1PnU8OV6AJgSFaee/covXBcPbWc6XDDxtEPlbi3EMQ6nUiPaQtw==", + "version": "1.22.1", + "resolved": "https://registry.npmjs.org/@azure/core-rest-pipeline/-/core-rest-pipeline-1.22.1.tgz", + "integrity": "sha512-UVZlVLfLyz6g3Hy7GNDpooMQonUygH7ghdiSASOOHy97fKj/mPLqgDX7aidOijn+sCMU+WU8NjlPlNTgnvbcGA==", "dev": true, "requires": { - "@azure/abort-controller": "^2.0.0", - "@azure/core-auth": "^1.8.0", - "@azure/core-tracing": "^1.0.1", - "@azure/core-util": "^1.11.0", - "@azure/logger": "^1.0.0", + "@azure/abort-controller": "^2.1.2", + "@azure/core-auth": "^1.10.0", + "@azure/core-tracing": "^1.3.0", + "@azure/core-util": "^1.13.0", + "@azure/logger": "^1.3.0", "@typespec/ts-http-runtime": "^0.3.0", "tslib": "^2.6.2" } }, "@azure/core-tracing": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/@azure/core-tracing/-/core-tracing-1.3.0.tgz", - "integrity": "sha512-+XvmZLLWPe67WXNZo9Oc9CrPj/Tm8QnHR92fFAFdnbzwNdCH1h+7UdpaQgRSBsMY+oW1kHXNUZQLdZ1gHX3ROw==", + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@azure/core-tracing/-/core-tracing-1.3.1.tgz", + "integrity": "sha512-9MWKevR7Hz8kNzzPLfX4EAtGM2b8mr50HPDBvio96bURP/9C+HjdH3sBlLSNNrvRAr5/k/svoH457gB5IKpmwQ==", "dev": true, "requires": { "tslib": "^2.6.2" } }, "@azure/core-util": { - "version": "1.13.0", - "resolved": "https://registry.npmjs.org/@azure/core-util/-/core-util-1.13.0.tgz", - "integrity": "sha512-o0psW8QWQ58fq3i24Q1K2XfS/jYTxr7O1HRcyUE9bV9NttLU+kYOH82Ixj8DGlMTOWgxm1Sss2QAfKK5UkSPxw==", + "version": "1.13.1", + "resolved": "https://registry.npmjs.org/@azure/core-util/-/core-util-1.13.1.tgz", + "integrity": "sha512-XPArKLzsvl0Hf0CaGyKHUyVgF7oDnhKoP85Xv6M4StF/1AhfORhZudHtOyf2s+FcbuQ9dPRAjB8J2KvRRMUK2A==", "dev": true, "requires": { - "@azure/abort-controller": "^2.0.0", + "@azure/abort-controller": "^2.1.2", "@typespec/ts-http-runtime": "^0.3.0", "tslib": "^2.6.2" } }, "@azure/identity": { - "version": "4.11.1", - "resolved": "https://registry.npmjs.org/@azure/identity/-/identity-4.11.1.tgz", - "integrity": "sha512-0ZdsLRaOyLxtCYgyuqyWqGU5XQ9gGnjxgfoNTt1pvELGkkUFrMATABZFIq8gusM7N1qbqpVtwLOhk0d/3kacLg==", + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/@azure/identity/-/identity-4.12.0.tgz", + "integrity": "sha512-6vuh2R3Cte6SD6azNalLCjIDoryGdcvDVEV7IDRPtm5lHX5ffkDlIalaoOp5YJU08e4ipjJENel20kSMDLAcug==", "dev": true, "requires": { "@azure/abort-controller": "^2.0.0", @@ -5511,27 +5495,27 @@ } }, "@azure/msal-browser": { - "version": "4.19.0", - "resolved": "https://registry.npmjs.org/@azure/msal-browser/-/msal-browser-4.19.0.tgz", - "integrity": "sha512-g6Ea+sJmK7l5NUyrPhtD7DNj/tZcsr6VTNNLNuYs8yPvL3HNiIpO/0kzXntF9AqJ/6L+uz9aHmoT1x+RNq6zBQ==", + "version": "4.24.1", + "resolved": "https://registry.npmjs.org/@azure/msal-browser/-/msal-browser-4.24.1.tgz", + "integrity": "sha512-e4sp8ihJIyZQvN0ZM1MMuKlEiiLWUS9V9+kxsVAc6K8MtpXHui8VINmKUxXH0OOksLhFDpdq4sGW1w6uYp431A==", "dev": true, "requires": { - "@azure/msal-common": "15.10.0" + "@azure/msal-common": "15.13.0" } }, "@azure/msal-common": { - "version": "15.10.0", - "resolved": "https://registry.npmjs.org/@azure/msal-common/-/msal-common-15.10.0.tgz", - "integrity": "sha512-+cGnma71NV3jzl6DdgdHsqriN4ZA7puBIzObSYCvcIVGMULGb2NrcOGV6IJxO06HoVRHFKijkxd9lcBvS063KQ==", + "version": "15.13.0", + "resolved": "https://registry.npmjs.org/@azure/msal-common/-/msal-common-15.13.0.tgz", + "integrity": "sha512-8oF6nj02qX7eE/6+wFT5NluXRHc05AgdCC3fJnkjiJooq8u7BcLmxaYYSwc2AfEkWRMRi6Eyvvbeqk4U4412Ag==", "dev": true }, "@azure/msal-node": { - "version": "3.7.0", - "resolved": "https://registry.npmjs.org/@azure/msal-node/-/msal-node-3.7.0.tgz", - "integrity": "sha512-WsL11pT0hnoIr/4NCjG6uJswkmNA/9AgEre4mSQZS2e+ZPKUWwUdA5nCTnr4n1FMT1O5ezSEiJushnPW25Y+dA==", + "version": "3.8.0", + "resolved": "https://registry.npmjs.org/@azure/msal-node/-/msal-node-3.8.0.tgz", + "integrity": "sha512-23BXm82Mp5XnRhrcd4mrHa0xuUNRp96ivu3nRatrfdAqjoeWAGyD0eEAafxAOHAEWWmdlyFK4ELFcdziXyw2sA==", "dev": true, "requires": { - "@azure/msal-common": "15.10.0", + "@azure/msal-common": "15.13.0", "jsonwebtoken": "^9.0.0", "uuid": "^8.3.0" } @@ -5554,247 +5538,240 @@ "dev": true }, "@dprint/darwin-arm64": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/@dprint/darwin-arm64/-/darwin-arm64-0.50.1.tgz", - "integrity": "sha512-NNKf3dxXn567pd/hpCVLHLbC0dI7s3YvQnUEwjRTOAQVMp6O7/ME+Tg1RPGsDP1IB+Y2fIYSM4qmG02zQrqjAQ==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/@dprint/darwin-arm64/-/darwin-arm64-0.50.2.tgz", + "integrity": "sha512-4d08INZlTxbPW9LK9W8+93viN543/qA2Kxn4azVnPW/xCb2Im03UqJBz8mMm3nJZdtNnK3uTVG3ib1VW+XJisw==", "dev": true, "optional": true }, "@dprint/darwin-x64": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/@dprint/darwin-x64/-/darwin-x64-0.50.1.tgz", - "integrity": "sha512-PcY75U3UC/0CLOxWzE0zZJZ2PxzUM5AX2baYL1ovgDGCfqO1H0hINiyxfx/8ncGgPojWBkLs+zrcFiGnXx7BQg==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/@dprint/darwin-x64/-/darwin-x64-0.50.2.tgz", + "integrity": "sha512-ZXWPBwdLojhdBATq+bKwJvB7D8bIzrD6eR/Xuq9UYE7evQazUiR069d9NPF0iVuzTo6wNf9ub9SXI7qDl11EGA==", "dev": true, "optional": true }, "@dprint/linux-arm64-glibc": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/@dprint/linux-arm64-glibc/-/linux-arm64-glibc-0.50.1.tgz", - "integrity": "sha512-q0TOGy9FsoSKsEQ4sIMKyFweF5M8rW1S5OfwJDNRR2TU2riWByU9TKYIZUzg53iuwYKRypr/kJ5kdbl516afRQ==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/@dprint/linux-arm64-glibc/-/linux-arm64-glibc-0.50.2.tgz", + "integrity": "sha512-marxQzRw8atXAnaawwZHeeUaaAVewrGTlFKKcDASGyjPBhc23J5fHPUPremm8xCbgYZyTlokzrV8/1rDRWhJcw==", "dev": true, "optional": true }, "@dprint/linux-arm64-musl": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/@dprint/linux-arm64-musl/-/linux-arm64-musl-0.50.1.tgz", - "integrity": "sha512-XRtxN2cA9rc06WFzzVPDIZYGGLmUXqpVf3F0XhhHV77ikQLJZ5reF4xBOQ+0HjJ/zy8W/HzuGDAHedWyCrRf9g==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/@dprint/linux-arm64-musl/-/linux-arm64-musl-0.50.2.tgz", + "integrity": "sha512-oGDq44ydzo0ZkJk6RHcUzUN5sOMT5HC6WA8kHXI6tkAsLUkaLO2DzZFfW4aAYZUn+hYNpQfQD8iGew0sjkyLyg==", "dev": true, "optional": true }, "@dprint/linux-riscv64-glibc": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/@dprint/linux-riscv64-glibc/-/linux-riscv64-glibc-0.50.1.tgz", - "integrity": "sha512-vAk/eYhSjA3LJ/yuYgxkHamiK8+m6YdqVBO/Ka+i16VxyjQyOdcMKBkrLCIqSxgyXd6b8raf9wM59HJbaIpoOg==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/@dprint/linux-riscv64-glibc/-/linux-riscv64-glibc-0.50.2.tgz", + "integrity": "sha512-QMmZoZYWsXezDcC03fBOwPfxhTpPEyHqutcgJ0oauN9QcSXGji9NSZITMmtLz2Ki3T1MIvdaLd1goGzNSvNqTQ==", "dev": true, "optional": true }, "@dprint/linux-x64-glibc": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/@dprint/linux-x64-glibc/-/linux-x64-glibc-0.50.1.tgz", - "integrity": "sha512-EpW5KLekaq4hXmKBWWtfBgZ244S4C+vFmMOd1YaGi8+f0hmPTJzVWLdIgpO2ZwfPQ5iycaVI/JS514PQmXPOvg==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/@dprint/linux-x64-glibc/-/linux-x64-glibc-0.50.2.tgz", + "integrity": "sha512-KMeHEzb4teQJChTgq8HuQzc+reRNDnarOTGTQovAZ9WNjOtKLViftsKWW5HsnRHtP5nUIPE9rF1QLjJ/gUsqvw==", "dev": true, "optional": true }, "@dprint/linux-x64-musl": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/@dprint/linux-x64-musl/-/linux-x64-musl-0.50.1.tgz", - "integrity": "sha512-assISBbaKKL8LkjrIy/5tpE157MVW6HbyIKAjTtg3tPNM3lDn1oH3twuGtK9WBsN/VoEP3QMZVauolcUJT/VOg==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/@dprint/linux-x64-musl/-/linux-x64-musl-0.50.2.tgz", + "integrity": "sha512-qM37T7H69g5coBTfE7SsA+KZZaRBky6gaUhPgAYxW+fOsoVtZSVkXtfTtQauHTpqqOEtbxfCtum70Hz1fr1teg==", "dev": true, "optional": true }, "@dprint/win32-arm64": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/@dprint/win32-arm64/-/win32-arm64-0.50.1.tgz", - "integrity": "sha512-ZeaRMQYoFjrsO3lvI1SqzDWDGH1GGXWmNSeXvcFuAf2OgYQJWMBlLotCKiHNJ3uyYneoyhTg2tv9QkApNkZV4Q==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/@dprint/win32-arm64/-/win32-arm64-0.50.2.tgz", + "integrity": "sha512-kuGVHGoxLwssVDsodefUIYQRoO2fQncurH/xKgXiZwMPOSzFcgUzYJQiyqmJEp+PENhO9VT1hXUHZtlyCAWBUQ==", "dev": true, "optional": true }, "@dprint/win32-x64": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/@dprint/win32-x64/-/win32-x64-0.50.1.tgz", - "integrity": "sha512-pMm8l/hRZ9zYylKw/yCaYkSV3btYB9UyMDbWqyxNthkQ1gckWrk17VTI6WjwwQuHD4Iaz5JgAYLS36hlUzWkxA==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/@dprint/win32-x64/-/win32-x64-0.50.2.tgz", + "integrity": "sha512-N3l9k31c3IMfVXqL0L6ygIhJFvCIrfQ+Z5Jph6RnCcBO6oDYWeYhAv/qBk1vLsF2y/e79TKsR1tvaEwnrQ03XA==", "dev": true, "optional": true }, "@esbuild/aix-ppc64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.8.tgz", - "integrity": "sha512-urAvrUedIqEiFR3FYSLTWQgLu5tb+m0qZw0NBEasUeo6wuqatkMDaRT+1uABiGXEu5vqgPd7FGE1BhsAIy9QVA==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.10.tgz", + "integrity": "sha512-0NFWnA+7l41irNuaSVlLfgNT12caWJVLzp5eAVhZ0z1qpxbockccEt3s+149rE64VUI3Ml2zt8Nv5JVc4QXTsw==", "dev": true, "optional": true }, "@esbuild/android-arm": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.8.tgz", - "integrity": "sha512-RONsAvGCz5oWyePVnLdZY/HHwA++nxYWIX1atInlaW6SEkwq6XkP3+cb825EUcRs5Vss/lGh/2YxAb5xqc07Uw==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.10.tgz", + "integrity": "sha512-dQAxF1dW1C3zpeCDc5KqIYuZ1tgAdRXNoZP7vkBIRtKZPYe2xVr/d3SkirklCHudW1B45tGiUlz2pUWDfbDD4w==", "dev": true, "optional": true }, "@esbuild/android-arm64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.8.tgz", - "integrity": "sha512-OD3p7LYzWpLhZEyATcTSJ67qB5D+20vbtr6vHlHWSQYhKtzUYrETuWThmzFpZtFsBIxRvhO07+UgVA9m0i/O1w==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.10.tgz", + "integrity": "sha512-LSQa7eDahypv/VO6WKohZGPSJDq5OVOo3UoFR1E4t4Gj1W7zEQMUhI+lo81H+DtB+kP+tDgBp+M4oNCwp6kffg==", "dev": true, "optional": true }, "@esbuild/android-x64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.8.tgz", - "integrity": "sha512-yJAVPklM5+4+9dTeKwHOaA+LQkmrKFX96BM0A/2zQrbS6ENCmxc4OVoBs5dPkCCak2roAD+jKCdnmOqKszPkjA==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.10.tgz", + "integrity": "sha512-MiC9CWdPrfhibcXwr39p9ha1x0lZJ9KaVfvzA0Wxwz9ETX4v5CHfF09bx935nHlhi+MxhA63dKRRQLiVgSUtEg==", "dev": true, "optional": true }, "@esbuild/darwin-arm64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.8.tgz", - "integrity": "sha512-Jw0mxgIaYX6R8ODrdkLLPwBqHTtYHJSmzzd+QeytSugzQ0Vg4c5rDky5VgkoowbZQahCbsv1rT1KW72MPIkevw==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.10.tgz", + "integrity": "sha512-JC74bdXcQEpW9KkV326WpZZjLguSZ3DfS8wrrvPMHgQOIEIG/sPXEN/V8IssoJhbefLRcRqw6RQH2NnpdprtMA==", "dev": true, "optional": true }, "@esbuild/darwin-x64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.8.tgz", - "integrity": "sha512-Vh2gLxxHnuoQ+GjPNvDSDRpoBCUzY4Pu0kBqMBDlK4fuWbKgGtmDIeEC081xi26PPjn+1tct+Bh8FjyLlw1Zlg==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.10.tgz", + "integrity": "sha512-tguWg1olF6DGqzws97pKZ8G2L7Ig1vjDmGTwcTuYHbuU6TTjJe5FXbgs5C1BBzHbJ2bo1m3WkQDbWO2PvamRcg==", "dev": true, "optional": true }, "@esbuild/freebsd-arm64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.8.tgz", - "integrity": "sha512-YPJ7hDQ9DnNe5vxOm6jaie9QsTwcKedPvizTVlqWG9GBSq+BuyWEDazlGaDTC5NGU4QJd666V0yqCBL2oWKPfA==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.10.tgz", + "integrity": "sha512-3ZioSQSg1HT2N05YxeJWYR+Libe3bREVSdWhEEgExWaDtyFbbXWb49QgPvFH8u03vUPX10JhJPcz7s9t9+boWg==", "dev": true, "optional": true }, "@esbuild/freebsd-x64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.8.tgz", - "integrity": "sha512-MmaEXxQRdXNFsRN/KcIimLnSJrk2r5H8v+WVafRWz5xdSVmWLoITZQXcgehI2ZE6gioE6HirAEToM/RvFBeuhw==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.10.tgz", + "integrity": "sha512-LLgJfHJk014Aa4anGDbh8bmI5Lk+QidDmGzuC2D+vP7mv/GeSN+H39zOf7pN5N8p059FcOfs2bVlrRr4SK9WxA==", "dev": true, "optional": true }, "@esbuild/linux-arm": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.8.tgz", - "integrity": "sha512-FuzEP9BixzZohl1kLf76KEVOsxtIBFwCaLupVuk4eFVnOZfU+Wsn+x5Ryam7nILV2pkq2TqQM9EZPsOBuMC+kg==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.10.tgz", + "integrity": "sha512-oR31GtBTFYCqEBALI9r6WxoU/ZofZl962pouZRTEYECvNF/dtXKku8YXcJkhgK/beU+zedXfIzHijSRapJY3vg==", "dev": true, "optional": true }, "@esbuild/linux-arm64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.8.tgz", - "integrity": "sha512-WIgg00ARWv/uYLU7lsuDK00d/hHSfES5BzdWAdAig1ioV5kaFNrtK8EqGcUBJhYqotlUByUKz5Qo6u8tt7iD/w==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.10.tgz", + "integrity": "sha512-5luJWN6YKBsawd5f9i4+c+geYiVEw20FVW5x0v1kEMWNq8UctFjDiMATBxLvmmHA4bf7F6hTRaJgtghFr9iziQ==", "dev": true, "optional": true }, "@esbuild/linux-ia32": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.8.tgz", - "integrity": "sha512-A1D9YzRX1i+1AJZuFFUMP1E9fMaYY+GnSQil9Tlw05utlE86EKTUA7RjwHDkEitmLYiFsRd9HwKBPEftNdBfjg==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.10.tgz", + "integrity": "sha512-NrSCx2Kim3EnnWgS4Txn0QGt0Xipoumb6z6sUtl5bOEZIVKhzfyp/Lyw4C1DIYvzeW/5mWYPBFJU3a/8Yr75DQ==", "dev": true, "optional": true }, "@esbuild/linux-loong64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.8.tgz", - "integrity": "sha512-O7k1J/dwHkY1RMVvglFHl1HzutGEFFZ3kNiDMSOyUrB7WcoHGf96Sh+64nTRT26l3GMbCW01Ekh/ThKM5iI7hQ==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.10.tgz", + "integrity": "sha512-xoSphrd4AZda8+rUDDfD9J6FUMjrkTz8itpTITM4/xgerAZZcFW7Dv+sun7333IfKxGG8gAq+3NbfEMJfiY+Eg==", "dev": true, "optional": true }, "@esbuild/linux-mips64el": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.8.tgz", - "integrity": "sha512-uv+dqfRazte3BzfMp8PAQXmdGHQt2oC/y2ovwpTteqrMx2lwaksiFZ/bdkXJC19ttTvNXBuWH53zy/aTj1FgGw==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.10.tgz", + "integrity": "sha512-ab6eiuCwoMmYDyTnyptoKkVS3k8fy/1Uvq7Dj5czXI6DF2GqD2ToInBI0SHOp5/X1BdZ26RKc5+qjQNGRBelRA==", "dev": true, "optional": true }, "@esbuild/linux-ppc64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.8.tgz", - "integrity": "sha512-GyG0KcMi1GBavP5JgAkkstMGyMholMDybAf8wF5A70CALlDM2p/f7YFE7H92eDeH/VBtFJA5MT4nRPDGg4JuzQ==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.10.tgz", + "integrity": "sha512-NLinzzOgZQsGpsTkEbdJTCanwA5/wozN9dSgEl12haXJBzMTpssebuXR42bthOF3z7zXFWH1AmvWunUCkBE4EA==", "dev": true, "optional": true }, "@esbuild/linux-riscv64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.8.tgz", - "integrity": "sha512-rAqDYFv3yzMrq7GIcen3XP7TUEG/4LK86LUPMIz6RT8A6pRIDn0sDcvjudVZBiiTcZCY9y2SgYX2lgK3AF+1eg==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.10.tgz", + "integrity": "sha512-FE557XdZDrtX8NMIeA8LBJX3dC2M8VGXwfrQWU7LB5SLOajfJIxmSdyL/gU1m64Zs9CBKvm4UAuBp5aJ8OgnrA==", "dev": true, "optional": true }, "@esbuild/linux-s390x": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.8.tgz", - "integrity": "sha512-Xutvh6VjlbcHpsIIbwY8GVRbwoviWT19tFhgdA7DlenLGC/mbc3lBoVb7jxj9Z+eyGqvcnSyIltYUrkKzWqSvg==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.10.tgz", + "integrity": "sha512-3BBSbgzuB9ajLoVZk0mGu+EHlBwkusRmeNYdqmznmMc9zGASFjSsxgkNsqmXugpPk00gJ0JNKh/97nxmjctdew==", "dev": true, "optional": true }, "@esbuild/linux-x64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.8.tgz", - "integrity": "sha512-ASFQhgY4ElXh3nDcOMTkQero4b1lgubskNlhIfJrsH5OKZXDpUAKBlNS0Kx81jwOBp+HCeZqmoJuihTv57/jvQ==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.10.tgz", + "integrity": "sha512-QSX81KhFoZGwenVyPoberggdW1nrQZSvfVDAIUXr3WqLRZGZqWk/P4T8p2SP+de2Sr5HPcvjhcJzEiulKgnxtA==", "dev": true, "optional": true }, "@esbuild/netbsd-arm64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.8.tgz", - "integrity": "sha512-d1KfruIeohqAi6SA+gENMuObDbEjn22olAR7egqnkCD9DGBG0wsEARotkLgXDu6c4ncgWTZJtN5vcgxzWRMzcw==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.10.tgz", + "integrity": "sha512-AKQM3gfYfSW8XRk8DdMCzaLUFB15dTrZfnX8WXQoOUpUBQ+NaAFCP1kPS/ykbbGYz7rxn0WS48/81l9hFl3u4A==", "dev": true, "optional": true }, "@esbuild/netbsd-x64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.8.tgz", - "integrity": "sha512-nVDCkrvx2ua+XQNyfrujIG38+YGyuy2Ru9kKVNyh5jAys6n+l44tTtToqHjino2My8VAY6Lw9H7RI73XFi66Cg==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.10.tgz", + "integrity": "sha512-7RTytDPGU6fek/hWuN9qQpeGPBZFfB4zZgcz2VK2Z5VpdUxEI8JKYsg3JfO0n/Z1E/6l05n0unDCNc4HnhQGig==", "dev": true, "optional": true }, "@esbuild/openbsd-arm64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.8.tgz", - "integrity": "sha512-j8HgrDuSJFAujkivSMSfPQSAa5Fxbvk4rgNAS5i3K+r8s1X0p1uOO2Hl2xNsGFppOeHOLAVgYwDVlmxhq5h+SQ==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.10.tgz", + "integrity": "sha512-5Se0VM9Wtq797YFn+dLimf2Zx6McttsH2olUBsDml+lm0GOCRVebRWUvDtkY4BWYv/3NgzS8b/UM3jQNh5hYyw==", "dev": true, "optional": true }, "@esbuild/openbsd-x64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.8.tgz", - "integrity": "sha512-1h8MUAwa0VhNCDp6Af0HToI2TJFAn1uqT9Al6DJVzdIBAd21m/G0Yfc77KDM3uF3T/YaOgQq3qTJHPbTOInaIQ==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.10.tgz", + "integrity": "sha512-XkA4frq1TLj4bEMB+2HnI0+4RnjbuGZfet2gs/LNs5Hc7D89ZQBHQ0gL2ND6Lzu1+QVkjp3x1gIcPKzRNP8bXw==", "dev": true, "optional": true }, "@esbuild/openharmony-arm64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.8.tgz", - "integrity": "sha512-r2nVa5SIK9tSWd0kJd9HCffnDHKchTGikb//9c7HX+r+wHYCpQrSgxhlY6KWV1nFo1l4KFbsMlHk+L6fekLsUg==", - "dev": true, - "optional": true - }, - "@esbuild/sunos-x64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.8.tgz", - "integrity": "sha512-zUlaP2S12YhQ2UzUfcCuMDHQFJyKABkAjvO5YSndMiIkMimPmxA+BYSBikWgsRpvyxuRnow4nS5NPnf9fpv41w==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.10.tgz", + "integrity": "sha512-AVTSBhTX8Y/Fz6OmIVBip9tJzZEUcY8WLh7I59+upa5/GPhh2/aM6bvOMQySspnCCHvFi79kMtdJS1w0DXAeag==", "dev": true, "optional": true }, "@esbuild/win32-arm64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.8.tgz", - "integrity": "sha512-YEGFFWESlPva8hGL+zvj2z/SaK+pH0SwOM0Nc/d+rVnW7GSTFlLBGzZkuSU9kFIGIo8q9X3ucpZhu8PDN5A2sQ==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.10.tgz", + "integrity": "sha512-ah+9b59KDTSfpaCg6VdJoOQvKjI33nTaQr4UluQwW7aEwZQsbMCfTmfEO4VyewOxx4RaDT/xCy9ra2GPWmO7Kw==", "dev": true, "optional": true }, "@esbuild/win32-ia32": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.8.tgz", - "integrity": "sha512-hiGgGC6KZ5LZz58OL/+qVVoZiuZlUYlYHNAmczOm7bs2oE1XriPFi5ZHHrS8ACpV5EjySrnoCKmcbQMN+ojnHg==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.10.tgz", + "integrity": "sha512-QHPDbKkrGO8/cz9LKVnJU22HOi4pxZnZhhA2HYHez5Pz4JeffhDjf85E57Oyco163GnzNCVkZK0b/n4Y0UHcSw==", "dev": true, "optional": true }, "@esbuild/win32-x64": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.8.tgz", - "integrity": "sha512-cn3Yr7+OaaZq1c+2pe+8yxC8E144SReCQjN6/2ynubzYjvyqZjTXfQJpAcQpsdJq3My7XADANiYGHoFC69pLQw==", + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.10.tgz", + "integrity": "sha512-9KpxSVFCu0iK1owoez6aC/s/EdUQLDN3adTxGCqxMVhrPDj6bt5dbrHDXUuq+Bs2vATFBBrQS5vdQ/Ed2P+nbw==", "dev": true, "optional": true }, @@ -5921,9 +5898,9 @@ }, "dependencies": { "chalk": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.5.0.tgz", - "integrity": "sha512-1tm8DTaJhPBG3bIkVeZt1iZM9GfSX2lzOeDVZH9R9ffRHpmHvxZ/QhgQH/aDTkswQVt+YHdXAdS/In/30OjCbg==", + "version": "5.6.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz", + "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==", "dev": true } } @@ -6003,22 +5980,22 @@ "dev": true }, "@textlint/ast-node-types": { - "version": "15.2.1", - "resolved": "https://registry.npmjs.org/@textlint/ast-node-types/-/ast-node-types-15.2.1.tgz", - "integrity": "sha512-20fEcLPsXg81yWpApv4FQxrZmlFF/Ta7/kz1HGIL+pJo5cSTmkc+eCki3GpOPZIoZk0tbJU8hrlwUb91F+3SNQ==", + "version": "15.2.2", + "resolved": "https://registry.npmjs.org/@textlint/ast-node-types/-/ast-node-types-15.2.2.tgz", + "integrity": "sha512-9ByYNzWV8tpz6BFaRzeRzIov8dkbSZu9q7IWqEIfmRuLWb2qbI/5gTvKcoWT1HYs4XM7IZ8TKSXcuPvMb6eorA==", "dev": true }, "@textlint/linter-formatter": { - "version": "15.2.1", - "resolved": "https://registry.npmjs.org/@textlint/linter-formatter/-/linter-formatter-15.2.1.tgz", - "integrity": "sha512-oollG/BHa07+mMt372amxHohteASC+Zxgollc1sZgiyxo4S6EuureV3a4QIQB0NecA+Ak3d0cl0WI/8nou38jw==", + "version": "15.2.2", + "resolved": "https://registry.npmjs.org/@textlint/linter-formatter/-/linter-formatter-15.2.2.tgz", + "integrity": "sha512-oMVaMJ3exFvXhCj3AqmCbLaeYrTNLqaJnLJMIlmnRM3/kZdxvku4OYdaDzgtlI194cVxamOY5AbHBBVnY79kEg==", "dev": true, "requires": { "@azu/format-text": "^1.0.2", "@azu/style-format": "^1.0.1", - "@textlint/module-interop": "15.2.1", - "@textlint/resolver": "15.2.1", - "@textlint/types": "15.2.1", + "@textlint/module-interop": "15.2.2", + "@textlint/resolver": "15.2.2", + "@textlint/types": "15.2.2", "chalk": "^4.1.2", "debug": "^4.4.1", "js-yaml": "^3.14.1", @@ -6120,24 +6097,24 @@ } }, "@textlint/module-interop": { - "version": "15.2.1", - "resolved": "https://registry.npmjs.org/@textlint/module-interop/-/module-interop-15.2.1.tgz", - "integrity": "sha512-b/C/ZNrm05n1ypymDknIcpkBle30V2ZgE3JVqQlA9PnQV46Ky510qrZk6s9yfKgA3m1YRnAw04m8xdVtqjq1qg==", + "version": "15.2.2", + "resolved": "https://registry.npmjs.org/@textlint/module-interop/-/module-interop-15.2.2.tgz", + "integrity": "sha512-2rmNcWrcqhuR84Iio1WRzlc4tEoOMHd6T7urjtKNNefpTt1owrTJ9WuOe60yD3FrTW0J/R0ux5wxUbP/eaeFOA==", "dev": true }, "@textlint/resolver": { - "version": "15.2.1", - "resolved": "https://registry.npmjs.org/@textlint/resolver/-/resolver-15.2.1.tgz", - "integrity": "sha512-FY3aK4tElEcOJVUsaMj4Zro4jCtKEEwUMIkDL0tcn6ljNcgOF7Em+KskRRk/xowFWayqDtdz5T3u7w/6fjjuJQ==", + "version": "15.2.2", + "resolved": "https://registry.npmjs.org/@textlint/resolver/-/resolver-15.2.2.tgz", + "integrity": "sha512-4hGWjmHt0y+5NAkoYZ8FvEkj8Mez9TqfbTm3BPjoV32cIfEixl2poTOgapn1rfm73905GSO3P1jiWjmgvii13Q==", "dev": true }, "@textlint/types": { - "version": "15.2.1", - "resolved": "https://registry.npmjs.org/@textlint/types/-/types-15.2.1.tgz", - "integrity": "sha512-zyqNhSatK1cwxDUgosEEN43hFh3WCty9Zm2Vm3ogU566IYegifwqN54ey/CiRy/DiO4vMcFHykuQnh2Zwp6LLw==", + "version": "15.2.2", + "resolved": "https://registry.npmjs.org/@textlint/types/-/types-15.2.2.tgz", + "integrity": "sha512-X2BHGAR3yXJsCAjwYEDBIk9qUDWcH4pW61ISfmtejau+tVqKtnbbvEZnMTb6mWgKU1BvTmftd5DmB1XVDUtY3g==", "dev": true, "requires": { - "@textlint/ast-node-types": "15.2.1" + "@textlint/ast-node-types": "15.2.2" } }, "@types/adm-zip": { @@ -6150,12 +6127,12 @@ } }, "@types/node": { - "version": "24.2.1", - "resolved": "https://registry.npmjs.org/@types/node/-/node-24.2.1.tgz", - "integrity": "sha512-DRh5K+ka5eJic8CjH7td8QpYEV6Zo10gfRkjHCO3weqZHWDtAaSTFtl4+VMqOJ4N5jcuhZ9/l+yy8rVgw7BQeQ==", + "version": "24.6.1", + "resolved": "https://registry.npmjs.org/@types/node/-/node-24.6.1.tgz", + "integrity": "sha512-ljvjjs3DNXummeIaooB4cLBKg2U6SPI6Hjra/9rRIy7CpM0HpLtG9HptkMKAb4HYWy5S7HUvJEuWgr/y0U8SHw==", "dev": true, "requires": { - "undici-types": "~7.10.0" + "undici-types": "~7.13.0" } }, "@types/normalize-package-data": { @@ -6171,9 +6148,9 @@ "dev": true }, "@types/vscode": { - "version": "1.102.0", - "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.102.0.tgz", - "integrity": "sha512-V9sFXmcXz03FtYTSUsYsu5K0Q9wH9w9V25slddcxrh5JgORD14LpnOA7ov0L9ALi+6HrTjskLJ/tY5zeRF3TFA==", + "version": "1.104.0", + "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.104.0.tgz", + "integrity": "sha512-0KwoU2rZ2ecsTGFxo4K1+f+AErRsYW0fsp6A0zufzGuhyczc2IoKqYqcwXidKXmy2u8YB2GsYsOtiI9Izx3Tig==", "dev": true }, "@types/which": { @@ -6195,16 +6172,16 @@ }, "@typescript/libsyncrpc": { "version": "git+ssh://git@github.com/microsoft/libsyncrpc.git#95d8cfcdd52a33169677fbc3b338a745accd7fdb", - "integrity": "sha512-SyPFGguQwJlUExSumvJxI1RnBq0i7KT2bhlBlZhMZfRtSkiGrywps/c+aC9wI2hiOydFGTgnH3vxi7rqiq7Dew==", + "integrity": "sha512-+cxoBpDD+MOdgpnUEIdkxskwV2rKFQwgxHyWTR4mH0ScXbWcRUQGQdP/J7dgVyjXUMZd+eCIY1ism7EdLIyKwg==", "from": "@typescript/libsyncrpc@github:microsoft/libsyncrpc#95d8cfcdd52a33169677fbc3b338a745accd7fdb" }, "@typescript/native-preview": { "version": "file:_packages/native-preview" }, "@typespec/ts-http-runtime": { - "version": "0.3.0", - "resolved": "https://registry.npmjs.org/@typespec/ts-http-runtime/-/ts-http-runtime-0.3.0.tgz", - "integrity": "sha512-sOx1PKSuFwnIl7z4RN0Ls7N9AQawmR9r66eI5rFCzLDIs8HTIYrIpH9QjYWoX0lkgGrkLxXhi4QnK7MizPRrIg==", + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/@typespec/ts-http-runtime/-/ts-http-runtime-0.3.1.tgz", + "integrity": "sha512-SnbaqayTVFEA6/tYumdF0UmybY0KHyKwGPBXnyckFlrrKdhWFrL3a2HIPXHjht5ZOElKGcXfD2D63P36btb+ww==", "dev": true, "requires": { "http-proxy-agent": "^7.0.0", @@ -6213,16 +6190,16 @@ } }, "@vscode/vsce": { - "version": "3.6.0", - "resolved": "https://registry.npmjs.org/@vscode/vsce/-/vsce-3.6.0.tgz", - "integrity": "sha512-u2ZoMfymRNJb14aHNawnXJtXHLXDVKc1oKZaH4VELKT/9iWKRVgtQOdwxCgtwSxJoqYvuK4hGlBWQJ05wxADhg==", + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/@vscode/vsce/-/vsce-3.6.2.tgz", + "integrity": "sha512-gvBfarWF+Ii20ESqjA3dpnPJpQJ8fFJYtcWtjwbRADommCzGg1emtmb34E+DKKhECYvaVyAl+TF9lWS/3GSPvg==", "dev": true, "requires": { "@azure/identity": "^4.1.0", - "@secretlint/node": "^10.1.1", - "@secretlint/secretlint-formatter-sarif": "^10.1.1", - "@secretlint/secretlint-rule-no-dotenv": "^10.1.1", - "@secretlint/secretlint-rule-preset-recommend": "^10.1.1", + "@secretlint/node": "^10.1.2", + "@secretlint/secretlint-formatter-sarif": "^10.1.2", + "@secretlint/secretlint-rule-no-dotenv": "^10.1.2", + "@secretlint/secretlint-rule-preset-recommend": "^10.1.2", "@vscode/vsce-sign": "^2.0.0", "azure-devops-node-api": "^12.5.0", "chalk": "^4.1.2", @@ -6240,7 +6217,7 @@ "minimatch": "^3.0.3", "parse-semver": "^1.1.1", "read": "^1.0.7", - "secretlint": "^10.1.1", + "secretlint": "^10.1.2", "semver": "^7.5.2", "tmp": "^0.2.3", "typed-rest-client": "^1.8.4", @@ -6335,9 +6312,9 @@ } }, "lru-cache": { - "version": "11.1.0", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.1.0.tgz", - "integrity": "sha512-QIXZUBJUx+2zHUdQujWejBkcD9+cs94tLn0+YL8UrCh+D5sCXZ4c7LaEH48pNwRY3MLDgqUFyhlCyjJPf1WP0A==", + "version": "11.2.2", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.2.tgz", + "integrity": "sha512-F9ODfyqML2coTIsQpSkRHnLSZMtkU8Q+mSfcaIyKwy58u+8k5nvAYeiNhsyMARvzNcXJ9QfWVrcPsC9e9rAxtg==", "dev": true }, "minimatch": { @@ -6371,82 +6348,82 @@ } }, "@vscode/vsce-sign": { - "version": "2.0.6", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign/-/vsce-sign-2.0.6.tgz", - "integrity": "sha512-j9Ashk+uOWCDHYDxgGsqzKq5FXW9b9MW7QqOIYZ8IYpneJclWTBeHZz2DJCSKQgo+JAqNcaRRE1hzIx0dswqAw==", + "version": "2.0.8", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign/-/vsce-sign-2.0.8.tgz", + "integrity": "sha512-H7p8E11cZMj6mt8xIi3QXZ7dSU/2MH3Y7c+5JfUhHAV4xfaPNc8ozwLVK282c6ah596KoIJIdPUlNHV7Qs/5JA==", "dev": true, "requires": { - "@vscode/vsce-sign-alpine-arm64": "2.0.5", - "@vscode/vsce-sign-alpine-x64": "2.0.5", - "@vscode/vsce-sign-darwin-arm64": "2.0.5", - "@vscode/vsce-sign-darwin-x64": "2.0.5", - "@vscode/vsce-sign-linux-arm": "2.0.5", - "@vscode/vsce-sign-linux-arm64": "2.0.5", - "@vscode/vsce-sign-linux-x64": "2.0.5", - "@vscode/vsce-sign-win32-arm64": "2.0.5", - "@vscode/vsce-sign-win32-x64": "2.0.5" + "@vscode/vsce-sign-alpine-arm64": "2.0.6", + "@vscode/vsce-sign-alpine-x64": "2.0.6", + "@vscode/vsce-sign-darwin-arm64": "2.0.2", + "@vscode/vsce-sign-darwin-x64": "2.0.2", + "@vscode/vsce-sign-linux-arm": "2.0.6", + "@vscode/vsce-sign-linux-arm64": "2.0.6", + "@vscode/vsce-sign-linux-x64": "2.0.6", + "@vscode/vsce-sign-win32-arm64": "2.0.6", + "@vscode/vsce-sign-win32-x64": "2.0.6" } }, "@vscode/vsce-sign-alpine-arm64": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-alpine-arm64/-/vsce-sign-alpine-arm64-2.0.5.tgz", - "integrity": "sha512-XVmnF40APwRPXSLYA28Ye+qWxB25KhSVpF2eZVtVOs6g7fkpOxsVnpRU1Bz2xG4ySI79IRuapDJoAQFkoOgfdQ==", + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-alpine-arm64/-/vsce-sign-alpine-arm64-2.0.6.tgz", + "integrity": "sha512-wKkJBsvKF+f0GfsUuGT0tSW0kZL87QggEiqNqK6/8hvqsXvpx8OsTEc3mnE1kejkh5r+qUyQ7PtF8jZYN0mo8Q==", "dev": true, "optional": true }, "@vscode/vsce-sign-alpine-x64": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-alpine-x64/-/vsce-sign-alpine-x64-2.0.5.tgz", - "integrity": "sha512-JuxY3xcquRsOezKq6PEHwCgd1rh1GnhyH6urVEWUzWn1c1PC4EOoyffMD+zLZtFuZF5qR1I0+cqDRNKyPvpK7Q==", + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-alpine-x64/-/vsce-sign-alpine-x64-2.0.6.tgz", + "integrity": "sha512-YoAGlmdK39vKi9jA18i4ufBbd95OqGJxRvF3n6ZbCyziwy3O+JgOpIUPxv5tjeO6gQfx29qBivQ8ZZTUF2Ba0w==", "dev": true, "optional": true }, "@vscode/vsce-sign-darwin-arm64": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-darwin-arm64/-/vsce-sign-darwin-arm64-2.0.5.tgz", - "integrity": "sha512-z2Q62bk0ptADFz8a0vtPvnm6vxpyP3hIEYMU+i1AWz263Pj8Mc38cm/4sjzxu+LIsAfhe9HzvYNS49lV+KsatQ==", + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-darwin-arm64/-/vsce-sign-darwin-arm64-2.0.2.tgz", + "integrity": "sha512-rz8F4pMcxPj8fjKAJIfkUT8ycG9CjIp888VY/6pq6cuI2qEzQ0+b5p3xb74CJnBbSC0p2eRVoe+WgNCAxCLtzQ==", "dev": true, "optional": true }, "@vscode/vsce-sign-darwin-x64": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-darwin-x64/-/vsce-sign-darwin-x64-2.0.5.tgz", - "integrity": "sha512-ma9JDC7FJ16SuPXlLKkvOD2qLsmW/cKfqK4zzM2iJE1PbckF3BlR08lYqHV89gmuoTpYB55+z8Y5Fz4wEJBVDA==", + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-darwin-x64/-/vsce-sign-darwin-x64-2.0.2.tgz", + "integrity": "sha512-MCjPrQ5MY/QVoZ6n0D92jcRb7eYvxAujG/AH2yM6lI0BspvJQxp0o9s5oiAM9r32r9tkLpiy5s2icsbwefAQIw==", "dev": true, "optional": true }, "@vscode/vsce-sign-linux-arm": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-linux-arm/-/vsce-sign-linux-arm-2.0.5.tgz", - "integrity": "sha512-cdCwtLGmvC1QVrkIsyzv01+o9eR+wodMJUZ9Ak3owhcGxPRB53/WvrDHAFYA6i8Oy232nuen1YqWeEohqBuSzA==", + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-linux-arm/-/vsce-sign-linux-arm-2.0.6.tgz", + "integrity": "sha512-UndEc2Xlq4HsuMPnwu7420uqceXjs4yb5W8E2/UkaHBB9OWCwMd3/bRe/1eLe3D8kPpxzcaeTyXiK3RdzS/1CA==", "dev": true, "optional": true }, "@vscode/vsce-sign-linux-arm64": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-linux-arm64/-/vsce-sign-linux-arm64-2.0.5.tgz", - "integrity": "sha512-Hr1o0veBymg9SmkCqYnfaiUnes5YK6k/lKFA5MhNmiEN5fNqxyPUCdRZMFs3Ajtx2OFW4q3KuYVRwGA7jdLo7Q==", + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-linux-arm64/-/vsce-sign-linux-arm64-2.0.6.tgz", + "integrity": "sha512-cfb1qK7lygtMa4NUl2582nP7aliLYuDEVpAbXJMkDq1qE+olIw/es+C8j1LJwvcRq1I2yWGtSn3EkDp9Dq5FdA==", "dev": true, "optional": true }, "@vscode/vsce-sign-linux-x64": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-linux-x64/-/vsce-sign-linux-x64-2.0.5.tgz", - "integrity": "sha512-XLT0gfGMcxk6CMRLDkgqEPTyG8Oa0OFe1tPv2RVbphSOjFWJwZgK3TYWx39i/7gqpDHlax0AP6cgMygNJrA6zg==", + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-linux-x64/-/vsce-sign-linux-x64-2.0.6.tgz", + "integrity": "sha512-/olerl1A4sOqdP+hjvJ1sbQjKN07Y3DVnxO4gnbn/ahtQvFrdhUi0G1VsZXDNjfqmXw57DmPi5ASnj/8PGZhAA==", "dev": true, "optional": true }, "@vscode/vsce-sign-win32-arm64": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-win32-arm64/-/vsce-sign-win32-arm64-2.0.5.tgz", - "integrity": "sha512-hco8eaoTcvtmuPhavyCZhrk5QIcLiyAUhEso87ApAWDllG7djIrWiOCtqn48k4pHz+L8oCQlE0nwNHfcYcxOPw==", + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-win32-arm64/-/vsce-sign-win32-arm64-2.0.6.tgz", + "integrity": "sha512-ivM/MiGIY0PJNZBoGtlRBM/xDpwbdlCWomUWuLmIxbi1Cxe/1nooYrEQoaHD8ojVRgzdQEUzMsRbyF5cJJgYOg==", "dev": true, "optional": true }, "@vscode/vsce-sign-win32-x64": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-win32-x64/-/vsce-sign-win32-x64-2.0.5.tgz", - "integrity": "sha512-1ixKFGM2FwM+6kQS2ojfY3aAelICxjiCzeg4nTHpkeU1Tfs4RC+lVLrgq5NwcBC7ZLr6UfY3Ct3D6suPeOf7BQ==", + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-win32-x64/-/vsce-sign-win32-x64-2.0.6.tgz", + "integrity": "sha512-mgth9Kvze+u8CruYMmhHw6Zgy3GRX2S+Ed5oSokDEK5vPEwGGKnmuXua9tmFhomeAnhgJnL4DCna3TiNuGrBTQ==", "dev": true, "optional": true }, @@ -6475,18 +6452,18 @@ } }, "ansi-escapes": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.0.0.tgz", - "integrity": "sha512-GdYO7a61mR0fOlAsvC9/rIHf7L96sBc6dEWzeOu+KAea5bZyQRPIpojrVoI4AXGJS/ycu/fBTdLrUkA4ODrvjw==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.1.1.tgz", + "integrity": "sha512-Zhl0ErHcSRUaVfGUeUdDuLgpkEo8KIFjB4Y9uAc46ScOpdDiU1Dbyplh7qWJeJ/ZHpbyMSM26+X3BySgnIz40Q==", "dev": true, "requires": { "environment": "^1.0.0" } }, "ansi-regex": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz", - "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==", + "version": "6.2.2", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz", + "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==", "dev": true }, "ansi-styles": { @@ -6811,9 +6788,9 @@ "dev": true }, "debug": { - "version": "4.4.1", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz", - "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==", + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", "dev": true, "requires": { "ms": "^2.1.3" @@ -6864,9 +6841,9 @@ "dev": true }, "detect-libc": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.4.tgz", - "integrity": "sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA==", + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.1.tgz", + "integrity": "sha512-ecqj/sy1jcK1uWrwpR67UhYrIFQ+5WlGxth34WquCbamhFA6hkkwiu37o6J5xCHdo1oixJRfVRw+ywV+Hq/0Aw==", "dev": true, "optional": true }, @@ -6908,20 +6885,20 @@ } }, "dprint": { - "version": "0.50.1", - "resolved": "https://registry.npmjs.org/dprint/-/dprint-0.50.1.tgz", - "integrity": "sha512-s+kUyQp2rGpwsM3vVmXySOY3v1NjYyRpKfQZdP4rfNTz6zQuICSO6nqIXNm3YdK1MwNFR/EXSFMuE1YPuulhow==", + "version": "0.50.2", + "resolved": "https://registry.npmjs.org/dprint/-/dprint-0.50.2.tgz", + "integrity": "sha512-+0Fzg+17jsMMUouK00/Fara5YtGOuE76EAJINHB8VpkXHd0n00rMXtw/03qorOgz23eo8Y0UpYvNZBJJo3aNtw==", "dev": true, "requires": { - "@dprint/darwin-arm64": "0.50.1", - "@dprint/darwin-x64": "0.50.1", - "@dprint/linux-arm64-glibc": "0.50.1", - "@dprint/linux-arm64-musl": "0.50.1", - "@dprint/linux-riscv64-glibc": "0.50.1", - "@dprint/linux-x64-glibc": "0.50.1", - "@dprint/linux-x64-musl": "0.50.1", - "@dprint/win32-arm64": "0.50.1", - "@dprint/win32-x64": "0.50.1" + "@dprint/darwin-arm64": "0.50.2", + "@dprint/darwin-x64": "0.50.2", + "@dprint/linux-arm64-glibc": "0.50.2", + "@dprint/linux-arm64-musl": "0.50.2", + "@dprint/linux-riscv64-glibc": "0.50.2", + "@dprint/linux-x64-glibc": "0.50.2", + "@dprint/linux-x64-musl": "0.50.2", + "@dprint/win32-arm64": "0.50.2", + "@dprint/win32-x64": "0.50.2" } }, "dunder-proto": { @@ -7031,37 +7008,37 @@ } }, "esbuild": { - "version": "0.25.8", - "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.8.tgz", - "integrity": "sha512-vVC0USHGtMi8+R4Kz8rt6JhEWLxsv9Rnu/lGYbPR8u47B+DCBksq9JarW0zOO7bs37hyOK1l2/oqtbciutL5+Q==", - "dev": true, - "requires": { - "@esbuild/aix-ppc64": "0.25.8", - "@esbuild/android-arm": "0.25.8", - "@esbuild/android-arm64": "0.25.8", - "@esbuild/android-x64": "0.25.8", - "@esbuild/darwin-arm64": "0.25.8", - "@esbuild/darwin-x64": "0.25.8", - "@esbuild/freebsd-arm64": "0.25.8", - "@esbuild/freebsd-x64": "0.25.8", - "@esbuild/linux-arm": "0.25.8", - "@esbuild/linux-arm64": "0.25.8", - "@esbuild/linux-ia32": "0.25.8", - "@esbuild/linux-loong64": "0.25.8", - "@esbuild/linux-mips64el": "0.25.8", - "@esbuild/linux-ppc64": "0.25.8", - "@esbuild/linux-riscv64": "0.25.8", - "@esbuild/linux-s390x": "0.25.8", - "@esbuild/linux-x64": "0.25.8", - "@esbuild/netbsd-arm64": "0.25.8", - "@esbuild/netbsd-x64": "0.25.8", - "@esbuild/openbsd-arm64": "0.25.8", - "@esbuild/openbsd-x64": "0.25.8", - "@esbuild/openharmony-arm64": "0.25.8", - "@esbuild/sunos-x64": "0.25.8", - "@esbuild/win32-arm64": "0.25.8", - "@esbuild/win32-ia32": "0.25.8", - "@esbuild/win32-x64": "0.25.8" + "version": "0.25.10", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.10.tgz", + "integrity": "sha512-9RiGKvCwaqxO2owP61uQ4BgNborAQskMR6QusfWzQqv7AZOg5oGehdY2pRJMTKuwxd1IDBP4rSbI5lHzU7SMsQ==", + "dev": true, + "requires": { + "@esbuild/aix-ppc64": "0.25.10", + "@esbuild/android-arm": "0.25.10", + "@esbuild/android-arm64": "0.25.10", + "@esbuild/android-x64": "0.25.10", + "@esbuild/darwin-arm64": "0.25.10", + "@esbuild/darwin-x64": "0.25.10", + "@esbuild/freebsd-arm64": "0.25.10", + "@esbuild/freebsd-x64": "0.25.10", + "@esbuild/linux-arm": "0.25.10", + "@esbuild/linux-arm64": "0.25.10", + "@esbuild/linux-ia32": "0.25.10", + "@esbuild/linux-loong64": "0.25.10", + "@esbuild/linux-mips64el": "0.25.10", + "@esbuild/linux-ppc64": "0.25.10", + "@esbuild/linux-riscv64": "0.25.10", + "@esbuild/linux-s390x": "0.25.10", + "@esbuild/linux-x64": "0.25.10", + "@esbuild/netbsd-arm64": "0.25.10", + "@esbuild/netbsd-x64": "0.25.10", + "@esbuild/openbsd-arm64": "0.25.10", + "@esbuild/openbsd-x64": "0.25.10", + "@esbuild/openharmony-arm64": "0.25.10", + "@esbuild/sunos-x64": "0.25.10", + "@esbuild/win32-arm64": "0.25.10", + "@esbuild/win32-ia32": "0.25.10", + "@esbuild/win32-x64": "0.25.10" } }, "escape-string-regexp": { @@ -7123,9 +7100,9 @@ } }, "fast-uri": { - "version": "3.0.6", - "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.0.6.tgz", - "integrity": "sha512-Atfo14OibSv5wAp4VWNsFYE1AchQRTv9cBGWET4pZWHzYshFSS9NQI6I57rdKn9croWVMbYFbLhJ+yJvmZIIHw==", + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.0.tgz", + "integrity": "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==", "dev": true }, "fastest-levenshtein": { @@ -7201,9 +7178,9 @@ "optional": true }, "fs-extra": { - "version": "11.3.1", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.1.tgz", - "integrity": "sha512-eXvGGwZ5CL17ZSwHWd3bbgk7UUpF6IFHtP57NYYakPvHOs8GDgDe5KJI36jIJzDkJ6eJjuzRA8eBQb6SkKue0g==", + "version": "11.3.2", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.2.tgz", + "integrity": "sha512-Xr9F6z6up6Ws+NjzMCZc6WXg2YFRlrLP9NQDO3VQrWrfiojdhS56TzueT88ze0uBdCTwEIhQ3ptnmKeWGFAe0A==", "dev": true, "requires": { "graceful-fs": "^4.2.0", @@ -7468,9 +7445,9 @@ "dev": true }, "index-to-position": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/index-to-position/-/index-to-position-1.1.0.tgz", - "integrity": "sha512-XPdx9Dq4t9Qk1mTMbWONJqU7boCoumEH7fRET37HX5+khDUl3J2W6PdALxhILYlIYx2amlwYcRPp28p0tSiojg==", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/index-to-position/-/index-to-position-1.2.0.tgz", + "integrity": "sha512-Yg7+ztRkqslMAS2iFaU+Oa4KTSidr63OsFGlOrJoW981kIYO3CGCS3wA95P1mUi/IVSJkn0D479KTJpVpvFNuw==", "dev": true }, "inherits": { @@ -7881,15 +7858,15 @@ "version": "file:_extension", "requires": { "@types/vscode": "^1.100.0", - "@vscode/vsce": "^3.6.0", - "esbuild": "^0.25.8", + "@vscode/vsce": "^3.6.2", + "esbuild": "^0.25.10", "vscode-languageclient": "^9.0.1" } }, "node-abi": { - "version": "3.75.0", - "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.75.0.tgz", - "integrity": "sha512-OhYaY5sDsIka7H7AtijtI9jwGYLyl29eQn/W623DiN/MIv5sUqc4g7BIDThX+gb7di9f6xK02nkp8sdfFWZLTg==", + "version": "3.77.0", + "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.77.0.tgz", + "integrity": "sha512-DSmt0OEcLoK4i3NuscSbGjOf3bqiDEutejqENSplMSFA/gmB8mkED9G4pKWnPl7MDU4rSHebKPHeitpDfyH0cQ==", "dev": true, "optional": true, "requires": { @@ -8149,9 +8126,9 @@ } }, "pretty-ms": { - "version": "9.2.0", - "resolved": "https://registry.npmjs.org/pretty-ms/-/pretty-ms-9.2.0.tgz", - "integrity": "sha512-4yf0QO/sllf/1zbZWYnvWw3NxCQwLXKzIj0G849LSufP15BXKM0rbD2Z3wVnkMfjdn/CB0Dpp444gYAACdsplg==", + "version": "9.3.0", + "resolved": "https://registry.npmjs.org/pretty-ms/-/pretty-ms-9.3.0.tgz", + "integrity": "sha512-gjVS5hOP+M3wMm5nmNOucbIrqudzs9v/57bWRHQWLYklXqoXKrVfYW2W9+glfGsqtPgpiz5WwyEEB+ksXIx3gQ==", "dev": true, "requires": { "parse-ms": "^4.0.0" @@ -8298,9 +8275,9 @@ "dev": true }, "run-applescript": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.0.0.tgz", - "integrity": "sha512-9by4Ij99JUr/MCFBUkDKLWK3G9HVXmabKz9U5MlIAIuvuzkiOicRYs8XJLxX+xahD+mLiiCYDqF9dKAgtzKP1A==", + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.1.0.tgz", + "integrity": "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==", "dev": true }, "run-parallel": { @@ -8575,9 +8552,9 @@ } }, "strip-ansi": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", - "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.2.tgz", + "integrity": "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==", "dev": true, "requires": { "ansi-regex": "^6.0.1" @@ -8718,9 +8695,9 @@ } }, "tar-fs": { - "version": "2.1.3", - "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.3.tgz", - "integrity": "sha512-090nwYJDmlhwFwEW3QQl+vaNnxsO2yVsd45eTKRBzSzu+hlb1w2K9inVq5b0ngXuLVqQ4ApvsUHHnu/zQNkWAg==", + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.4.tgz", + "integrity": "sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ==", "dev": true, "optional": true, "requires": { @@ -8830,9 +8807,9 @@ } }, "typescript": { - "version": "5.9.2", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.2.tgz", - "integrity": "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==", + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", "dev": true }, "typical": { @@ -8854,15 +8831,15 @@ "dev": true }, "undici": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/undici/-/undici-7.13.0.tgz", - "integrity": "sha512-l+zSMssRqrzDcb3fjMkjjLGmuiiK2pMIcV++mJaAc9vhjSGpvM7h43QgP+OAMb1GImHmbPyG2tBXeuyG5iY4gA==", + "version": "7.16.0", + "resolved": "https://registry.npmjs.org/undici/-/undici-7.16.0.tgz", + "integrity": "sha512-QEg3HPMll0o3t2ourKwOeUAZ159Kn9mx5pnzHRQO8+Wixmh88YdZRiIwat0iNzNNXn0yoEtXJqFpyW7eM8BV7g==", "dev": true }, "undici-types": { - "version": "7.10.0", - "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.10.0.tgz", - "integrity": "sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag==", + "version": "7.13.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.13.0.tgz", + "integrity": "sha512-Ov2Rr9Sx+fRgagJ5AX0qvItZG/JKKoBRAVITs1zk7IqZGTJUwgUr7qoYBpWwakpWilTZFM98rG/AFRocu10iIQ==", "dev": true }, "unicorn-magic": { @@ -8997,9 +8974,9 @@ }, "dependencies": { "ansi-styles": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", - "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", + "version": "6.2.3", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz", + "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==", "dev": true } } @@ -9137,9 +9114,9 @@ "dev": true }, "yoctocolors": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/yoctocolors/-/yoctocolors-2.1.1.tgz", - "integrity": "sha512-GQHQqAopRhwU8Kt1DDM8NjibDXHC8eoh1erhGAJPEyveY9qqVeXvVikNKrDz69sHowPMorbPUrH/mx8c50eiBQ==", + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/yoctocolors/-/yoctocolors-2.1.2.tgz", + "integrity": "sha512-CzhO+pFNo8ajLM2d2IW/R93ipy99LWjtwblvC1RsoSUMZgyLbYFr221TnSNT7GjGdYui6P459mw9JH/g/zW2ug==", "dev": true } } diff --git a/package.json b/package.json index a6b739464f..1372eda040 100644 --- a/package.json +++ b/package.json @@ -9,13 +9,13 @@ "@types/which": "^3.0.4", "adm-zip": "^0.5.16", "chokidar": "^4.0.3", - "dprint": "^0.50.1", + "dprint": "^0.50.2", "execa": "^9.6.0", "glob": "^10.4.5", "hereby": "^1.11.0", "p-limit": "^6.2.0", "picocolors": "^1.1.1", - "typescript": "^5.9.2", + "typescript": "^5.9.3", "which": "^5.0.0" }, "scripts": { diff --git a/testdata/baselines/reference/fourslash/documentHighlights/documentHighlightImportPath.baseline.jsonc b/testdata/baselines/reference/fourslash/documentHighlights/documentHighlightImportPath.baseline.jsonc new file mode 100644 index 0000000000..9990790b26 --- /dev/null +++ b/testdata/baselines/reference/fourslash/documentHighlights/documentHighlightImportPath.baseline.jsonc @@ -0,0 +1,3 @@ +// === documentHighlights === +// === /b.ts === +// import { x } from "/*HIGHLIGHTS*/[|./a|]"; \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/documentHighlights/getOccurrencesClassExpressionConstructor.baseline.jsonc b/testdata/baselines/reference/fourslash/documentHighlights/getOccurrencesClassExpressionConstructor.baseline.jsonc index fd11e991f0..7b5c4730a1 100644 --- a/testdata/baselines/reference/fourslash/documentHighlights/getOccurrencesClassExpressionConstructor.baseline.jsonc +++ b/testdata/baselines/reference/fourslash/documentHighlights/getOccurrencesClassExpressionConstructor.baseline.jsonc @@ -1,46 +1,52 @@ // === documentHighlights === // === /getOccurrencesClassExpressionConstructor.ts === -// let A = class [|Foo|] { -// /*HIGHLIGHTS*/constructor(); -// constructor(x: number); -// constructor(y: string); -// constructor(a?: any) { -// // --- (line: 6) skipped --- +// let A = class Foo { +// /*HIGHLIGHTS*/[|constructor|](); +// [|constructor|](x: number); +// [|constructor|](y: string); +// [|constructor|](a?: any) { +// } +// } +// +// // --- (line: 9) skipped --- // === documentHighlights === // === /getOccurrencesClassExpressionConstructor.ts === -// let A = class [|Foo|] { -// constructor(); -// /*HIGHLIGHTS*/constructor(x: number); -// constructor(y: string); -// constructor(a?: any) { +// let A = class Foo { +// [|constructor|](); +// /*HIGHLIGHTS*/[|constructor|](x: number); +// [|constructor|](y: string); +// [|constructor|](a?: any) { // } -// // --- (line: 7) skipped --- +// } +// +// // --- (line: 9) skipped --- // === documentHighlights === // === /getOccurrencesClassExpressionConstructor.ts === -// let A = class [|Foo|] { -// constructor(); -// constructor(x: number); -// /*HIGHLIGHTS*/constructor(y: string); -// constructor(a?: any) { +// let A = class Foo { +// [|constructor|](); +// [|constructor|](x: number); +// /*HIGHLIGHTS*/[|constructor|](y: string); +// [|constructor|](a?: any) { // } // } -// // --- (line: 8) skipped --- +// +// // --- (line: 9) skipped --- // === documentHighlights === // === /getOccurrencesClassExpressionConstructor.ts === -// let A = class [|Foo|] { -// constructor(); -// constructor(x: number); -// constructor(y: string); -// /*HIGHLIGHTS*/constructor(a?: any) { +// let A = class Foo { +// [|constructor|](); +// [|constructor|](x: number); +// [|constructor|](y: string); +// /*HIGHLIGHTS*/[|constructor|](a?: any) { // } // } // diff --git a/testdata/baselines/reference/fourslash/documentHighlights/getOccurrencesConstructor.baseline.jsonc b/testdata/baselines/reference/fourslash/documentHighlights/getOccurrencesConstructor.baseline.jsonc index 9931401544..9a0d835004 100644 --- a/testdata/baselines/reference/fourslash/documentHighlights/getOccurrencesConstructor.baseline.jsonc +++ b/testdata/baselines/reference/fourslash/documentHighlights/getOccurrencesConstructor.baseline.jsonc @@ -1,46 +1,52 @@ // === documentHighlights === // === /getOccurrencesConstructor.ts === -// class [|C|] { -// /*HIGHLIGHTS*/constructor(); -// constructor(x: number); -// constructor(y: string, x: number); -// constructor(a?: any, ...r: any[]) { -// // --- (line: 6) skipped --- +// class C { +// /*HIGHLIGHTS*/[|constructor|](); +// [|constructor|](x: number); +// [|constructor|](y: string, x: number); +// [|constructor|](a?: any, ...r: any[]) { +// if (a === undefined && r.length === 0) { +// return; +// } +// // --- (line: 9) skipped --- // === documentHighlights === // === /getOccurrencesConstructor.ts === -// class [|C|] { -// constructor(); -// /*HIGHLIGHTS*/constructor(x: number); -// constructor(y: string, x: number); -// constructor(a?: any, ...r: any[]) { +// class C { +// [|constructor|](); +// /*HIGHLIGHTS*/[|constructor|](x: number); +// [|constructor|](y: string, x: number); +// [|constructor|](a?: any, ...r: any[]) { // if (a === undefined && r.length === 0) { -// // --- (line: 7) skipped --- +// return; +// } +// // --- (line: 9) skipped --- // === documentHighlights === // === /getOccurrencesConstructor.ts === -// class [|C|] { -// constructor(); -// constructor(x: number); -// /*HIGHLIGHTS*/constructor(y: string, x: number); -// constructor(a?: any, ...r: any[]) { +// class C { +// [|constructor|](); +// [|constructor|](x: number); +// /*HIGHLIGHTS*/[|constructor|](y: string, x: number); +// [|constructor|](a?: any, ...r: any[]) { // if (a === undefined && r.length === 0) { // return; -// // --- (line: 8) skipped --- +// } +// // --- (line: 9) skipped --- // === documentHighlights === // === /getOccurrencesConstructor.ts === -// class [|C|] { -// constructor(); -// constructor(x: number); -// constructor(y: string, x: number); -// /*HIGHLIGHTS*/constructor(a?: any, ...r: any[]) { +// class C { +// [|constructor|](); +// [|constructor|](x: number); +// [|constructor|](y: string, x: number); +// /*HIGHLIGHTS*/[|constructor|](a?: any, ...r: any[]) { // if (a === undefined && r.length === 0) { // return; // } diff --git a/testdata/baselines/reference/fourslash/documentHighlights/getOccurrencesConstructor2.baseline.jsonc b/testdata/baselines/reference/fourslash/documentHighlights/getOccurrencesConstructor2.baseline.jsonc index 6f531d7015..786cff277a 100644 --- a/testdata/baselines/reference/fourslash/documentHighlights/getOccurrencesConstructor2.baseline.jsonc +++ b/testdata/baselines/reference/fourslash/documentHighlights/getOccurrencesConstructor2.baseline.jsonc @@ -1,10 +1,9 @@ // === documentHighlights === // === /getOccurrencesConstructor2.ts === -// --- (line: 10) skipped --- -// } +// --- (line: 11) skipped --- // } // -// class [|D|] { -// /*HIGHLIGHTS*/constructor(public x: number, public y: number) { +// class D { +// /*HIGHLIGHTS*/[|constructor|](public x: number, public y: number) { // } // } \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/findAllReferences/constructorFindAllReferences3.baseline.jsonc b/testdata/baselines/reference/fourslash/findAllReferences/constructorFindAllReferences3.baseline.jsonc index 9876967d32..79b101605b 100644 --- a/testdata/baselines/reference/fourslash/findAllReferences/constructorFindAllReferences3.baseline.jsonc +++ b/testdata/baselines/reference/fourslash/findAllReferences/constructorFindAllReferences3.baseline.jsonc @@ -1,7 +1,7 @@ // === findAllReferences === // === /constructorFindAllReferences3.ts === -// export class [|C|] { -// /*FIND ALL REFS*/constructor() { } +// export class C { +// /*FIND ALL REFS*/[|constructor|]() { } // public foo() { } // } // diff --git a/testdata/baselines/reference/fourslash/findAllReferences/findAllReferencesDynamicImport1.baseline.jsonc b/testdata/baselines/reference/fourslash/findAllReferences/findAllReferencesDynamicImport1.baseline.jsonc new file mode 100644 index 0000000000..cf2a41e027 --- /dev/null +++ b/testdata/baselines/reference/fourslash/findAllReferences/findAllReferencesDynamicImport1.baseline.jsonc @@ -0,0 +1,29 @@ +// === findAllReferences === +// === /foo.ts === +// export function foo() { return "foo"; } +// /*FIND ALL REFS*/import("./foo") +// var x = import("./foo") + + + +// === findAllReferences === +// === /foo.ts === +// export function foo() { return "foo"; } +// import("/*FIND ALL REFS*/[|./foo|]") +// var x = import("[|./foo|]") + + + +// === findAllReferences === +// === /foo.ts === +// export function foo() { return "foo"; } +// import("./foo") +// /*FIND ALL REFS*/var x = import("./foo") + + + +// === findAllReferences === +// === /foo.ts === +// export function foo() { return "foo"; } +// import("[|./foo|]") +// var x = import("/*FIND ALL REFS*/[|./foo|]") \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/findAllReferences/findAllReferencesOfConstructor.baseline.jsonc b/testdata/baselines/reference/fourslash/findAllReferences/findAllReferencesOfConstructor.baseline.jsonc index 8b8c2b5574..fc41d645a1 100644 --- a/testdata/baselines/reference/fourslash/findAllReferences/findAllReferencesOfConstructor.baseline.jsonc +++ b/testdata/baselines/reference/fourslash/findAllReferences/findAllReferencesOfConstructor.baseline.jsonc @@ -1,114 +1,105 @@ // === findAllReferences === // === /a.ts === -// export class [|C|] { -// /*FIND ALL REFS*/constructor(n: number); -// constructor(); -// constructor(n?: number){} +// export class C { +// /*FIND ALL REFS*/[|constructor|](n: number); +// [|constructor|](); +// [|constructor|](n?: number){} // static f() { // this.f(); -// new this(); +// new [|this|](); // } // } // new [|C|](); -// const D = [|C|]; +// const D = C; // new D(); // === /b.ts === -// import { [|C|] } from "./a"; +// import { C } from "./a"; // new [|C|](); // === /c.ts === -// import { [|C|] } from "./a"; -// class D extends [|C|] { +// import { C } from "./a"; +// class D extends C { // constructor() { -// super(); +// [|super|](); // super.method(); // } // method() { super(); } -// } -// class E implements [|C|] { -// constructor() { super(); } -// } +// // --- (line: 8) skipped --- // === /d.ts === // import * as a from "./a"; -// new a.[|C|](); -// class d extends a.[|C|] { constructor() { super(); } +// new a.C(); +// class d extends a.C { constructor() { [|super|](); } // === findAllReferences === // === /a.ts === -// export class [|C|] { -// constructor(n: number); -// /*FIND ALL REFS*/constructor(); -// constructor(n?: number){} +// export class C { +// [|constructor|](n: number); +// /*FIND ALL REFS*/[|constructor|](); +// [|constructor|](n?: number){} // static f() { // this.f(); -// new this(); +// new [|this|](); // } // } // new [|C|](); -// const D = [|C|]; +// const D = C; // new D(); // === /b.ts === -// import { [|C|] } from "./a"; +// import { C } from "./a"; // new [|C|](); // === /c.ts === -// import { [|C|] } from "./a"; -// class D extends [|C|] { +// import { C } from "./a"; +// class D extends C { // constructor() { -// super(); +// [|super|](); // super.method(); // } // method() { super(); } -// } -// class E implements [|C|] { -// constructor() { super(); } -// } +// // --- (line: 8) skipped --- // === /d.ts === // import * as a from "./a"; -// new a.[|C|](); -// class d extends a.[|C|] { constructor() { super(); } +// new a.C(); +// class d extends a.C { constructor() { [|super|](); } // === findAllReferences === // === /a.ts === -// export class [|C|] { -// constructor(n: number); -// constructor(); -// /*FIND ALL REFS*/constructor(n?: number){} +// export class C { +// [|constructor|](n: number); +// [|constructor|](); +// /*FIND ALL REFS*/[|constructor|](n?: number){} // static f() { // this.f(); -// new this(); +// new [|this|](); // } // } // new [|C|](); -// const D = [|C|]; +// const D = C; // new D(); // === /b.ts === -// import { [|C|] } from "./a"; +// import { C } from "./a"; // new [|C|](); // === /c.ts === -// import { [|C|] } from "./a"; -// class D extends [|C|] { +// import { C } from "./a"; +// class D extends C { // constructor() { -// super(); +// [|super|](); // super.method(); // } // method() { super(); } -// } -// class E implements [|C|] { -// constructor() { super(); } -// } +// // --- (line: 8) skipped --- // === /d.ts === // import * as a from "./a"; -// new a.[|C|](); -// class d extends a.[|C|] { constructor() { super(); } \ No newline at end of file +// new a.C(); +// class d extends a.C { constructor() { [|super|](); } \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/findAllReferences/findAllReferencesOfConstructor_badOverload.baseline.jsonc b/testdata/baselines/reference/fourslash/findAllReferences/findAllReferencesOfConstructor_badOverload.baseline.jsonc index 4c9e2f0c7e..9947e3cb5d 100644 --- a/testdata/baselines/reference/fourslash/findAllReferences/findAllReferencesOfConstructor_badOverload.baseline.jsonc +++ b/testdata/baselines/reference/fourslash/findAllReferences/findAllReferencesOfConstructor_badOverload.baseline.jsonc @@ -1,15 +1,15 @@ // === findAllReferences === // === /findAllReferencesOfConstructor_badOverload.ts === -// class [|C|] { -// /*FIND ALL REFS*/constructor(n: number); -// constructor(){} +// class C { +// /*FIND ALL REFS*/[|constructor|](n: number); +// [|constructor|](){} // } // === findAllReferences === // === /findAllReferencesOfConstructor_badOverload.ts === -// class [|C|] { -// constructor(n: number); -// /*FIND ALL REFS*/constructor(){} +// class C { +// [|constructor|](n: number); +// /*FIND ALL REFS*/[|constructor|](){} // } \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/findAllReferences/findAllReferencesUmdModuleAsGlobalConst.baseline.jsonc b/testdata/baselines/reference/fourslash/findAllReferences/findAllReferencesUmdModuleAsGlobalConst.baseline.jsonc new file mode 100644 index 0000000000..63169a81fa --- /dev/null +++ b/testdata/baselines/reference/fourslash/findAllReferences/findAllReferencesUmdModuleAsGlobalConst.baseline.jsonc @@ -0,0 +1,39 @@ +// === findAllReferences === +// === /node_modules/@types/three/index.d.ts === +// export * from "./three-core"; +// export as namespace /*FIND ALL REFS*/[|THREE|]; + + + +// === findAllReferences === +// === /typings/global.d.ts === +// import * as _THREE from '/*FIND ALL REFS*/[|three|]'; +// declare global { +// const THREE: typeof _THREE; +// } + + + +// === findAllReferences === +// === /src/index.ts === +// export const a = {}; +// let v = new [|THREE|].Vector2(); + +// === /typings/global.d.ts === +// import * as _THREE from 'three'; +// declare global { +// const /*FIND ALL REFS*/[|THREE|]: typeof _THREE; +// } + + + +// === findAllReferences === +// === /src/index.ts === +// export const a = {}; +// let v = new /*FIND ALL REFS*/[|THREE|].Vector2(); + +// === /typings/global.d.ts === +// import * as _THREE from 'three'; +// declare global { +// const [|THREE|]: typeof _THREE; +// } \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsClassWithStaticThisAccess.baseline.jsonc b/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsClassWithStaticThisAccess.baseline.jsonc index 6a8b752253..62eab0f718 100644 --- a/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsClassWithStaticThisAccess.baseline.jsonc +++ b/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsClassWithStaticThisAccess.baseline.jsonc @@ -2,9 +2,15 @@ // === /findAllRefsClassWithStaticThisAccess.ts === // class /*FIND ALL REFS*/[|C|] { // static s() { -// this; +// [|this|]; +// } +// static get f() { +// return [|this|]; +// +// function inner() { this; } +// class Inner { x = this; } // } -// // --- (line: 5) skipped --- +// } diff --git a/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsExportEquals.baseline.jsonc b/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsExportEquals.baseline.jsonc new file mode 100644 index 0000000000..3734653d91 --- /dev/null +++ b/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsExportEquals.baseline.jsonc @@ -0,0 +1,44 @@ +// === findAllReferences === +// === /a.ts === +// type /*FIND ALL REFS*/[|T|] = number; +// export = T; + + + +// === findAllReferences === +// === /a.ts === +// type T = number; +// /*FIND ALL REFS*/[|export|] = T; + +// === /b.ts === +// import T = require("[|./a|]"); + + + +// === findAllReferences === +// === /a.ts === +// type T = number; +// export = /*FIND ALL REFS*/[|T|]; + +// === /b.ts === +// import [|T|] = require("./a"); + + + +// === findAllReferences === +// === /a.ts === +// type [|T|] = number; +// export = [|T|]; + +// === /b.ts === +// import /*FIND ALL REFS*/[|T|] = require("./a"); + + + +// === findAllReferences === +// === /a.ts === +// type [|T|] = number; +// [|export|] = [|T|]; + +// === /b.ts === +// import [|T|] = require("/*FIND ALL REFS*/[|./a|]"); \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsIsDefinition.baseline.jsonc b/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsIsDefinition.baseline.jsonc index 40a30963df..b1d0fc3619 100644 --- a/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsIsDefinition.baseline.jsonc +++ b/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsIsDefinition.baseline.jsonc @@ -73,16 +73,15 @@ // === findAllReferences === // === /findAllRefsIsDefinition.ts === -// --- (line: 15) skipped --- -// interface IFoo { +// --- (line: 16) skipped --- // foo(): void; // } -// class [|Foo|] implements IFoo { -// constructor(n: number) -// constructor() -// /*FIND ALL REFS*/constructor(n: number?) { } +// class Foo implements IFoo { +// [|constructor|](n: number) +// [|constructor|]() +// /*FIND ALL REFS*/[|constructor|](n: number?) { } // foo(): void { } -// static init() { return new this() } +// static init() { return new [|this|]() } // } diff --git a/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsOfConstructor_withModifier.baseline.jsonc b/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsOfConstructor_withModifier.baseline.jsonc index 109ee85c9a..1843c960f8 100644 --- a/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsOfConstructor_withModifier.baseline.jsonc +++ b/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsOfConstructor_withModifier.baseline.jsonc @@ -1,6 +1,6 @@ // === findAllReferences === // === /findAllRefsOfConstructor_withModifier.ts === -// class [|X|] { -// public /*FIND ALL REFS*/constructor() {} +// class X { +// public /*FIND ALL REFS*/[|constructor|]() {} // } // var x = new [|X|](); \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/findAllReferences/findAllRefs_importType_typeofImport.baseline.jsonc b/testdata/baselines/reference/fourslash/findAllReferences/findAllRefs_importType_typeofImport.baseline.jsonc new file mode 100644 index 0000000000..33e67cb257 --- /dev/null +++ b/testdata/baselines/reference/fourslash/findAllReferences/findAllRefs_importType_typeofImport.baseline.jsonc @@ -0,0 +1,25 @@ +// === findAllReferences === +// === /b.ts === +// /*FIND ALL REFS*/const x: typeof import("./a") = { x: 0 }; +// const y: typeof import("./a") = { x: 0 }; + + + +// === findAllReferences === +// === /b.ts === +// const x: typeof import("/*FIND ALL REFS*/[|./a|]") = { x: 0 }; +// const y: typeof import("[|./a|]") = { x: 0 }; + + + +// === findAllReferences === +// === /b.ts === +// const x: typeof import("./a") = { x: 0 }; +// /*FIND ALL REFS*/const y: typeof import("./a") = { x: 0 }; + + + +// === findAllReferences === +// === /b.ts === +// const x: typeof import("[|./a|]") = { x: 0 }; +// const y: typeof import("/*FIND ALL REFS*/[|./a|]") = { x: 0 }; \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/findAllReferences/jsxFindAllReferencesOnRuntimeImportWithPaths1.baseline.jsonc b/testdata/baselines/reference/fourslash/findAllReferences/jsxFindAllReferencesOnRuntimeImportWithPaths1.baseline.jsonc new file mode 100644 index 0000000000..392e16b4b2 --- /dev/null +++ b/testdata/baselines/reference/fourslash/findAllReferences/jsxFindAllReferencesOnRuntimeImportWithPaths1.baseline.jsonc @@ -0,0 +1,3 @@ +// === findAllReferences === +// === /project/src/foo.ts === +// import * as x from /*FIND ALL REFS*/"[|@foo/dir/jsx-runtime|]"; \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/findAllReferences/referencesIsAvailableThroughGlobalNoCrash.baseline.jsonc b/testdata/baselines/reference/fourslash/findAllReferences/referencesIsAvailableThroughGlobalNoCrash.baseline.jsonc new file mode 100644 index 0000000000..9ae5412973 --- /dev/null +++ b/testdata/baselines/reference/fourslash/findAllReferences/referencesIsAvailableThroughGlobalNoCrash.baseline.jsonc @@ -0,0 +1,13 @@ +// === findAllReferences === +// === /packages/playwright-core/bundles/utils/node_modules/@types/debug/index.d.ts === +// declare var [|debug|]: [|debug|].Debug & { debug: [|debug|].Debug; default: [|debug|].Debug }; +// [|export|] = [|debug|]; +// export as namespace debug; +// declare namespace [|debug|] { +// interface Debug { +// coerce: (val: any) => any; +// } +// } + +// === /packages/playwright-core/src/index.ts === +// export const debug: typeof import('[|../bundles/utils/node_modules//*FIND ALL REFS*/@types/debug|]') = require('./utilsBundleImpl').debug; \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/findAllReferences/renameJsExports03.baseline.jsonc b/testdata/baselines/reference/fourslash/findAllReferences/renameJsExports03.baseline.jsonc index e7589d64b6..e6aca1fc85 100644 --- a/testdata/baselines/reference/fourslash/findAllReferences/renameJsExports03.baseline.jsonc +++ b/testdata/baselines/reference/fourslash/findAllReferences/renameJsExports03.baseline.jsonc @@ -9,10 +9,10 @@ // === findAllReferences === // === /a.js === -// class [|A|] { -// /*FIND ALL REFS*/constructor() { } +// class A { +// /*FIND ALL REFS*/[|constructor|]() { } // } -// module.exports = [|A|]; +// module.exports = A; diff --git a/testdata/baselines/reference/fourslash/findAllReferences/tslibFindAllReferencesOnRuntimeImportWithPaths1.baseline.jsonc b/testdata/baselines/reference/fourslash/findAllReferences/tslibFindAllReferencesOnRuntimeImportWithPaths1.baseline.jsonc new file mode 100644 index 0000000000..5276f7a8d4 --- /dev/null +++ b/testdata/baselines/reference/fourslash/findAllReferences/tslibFindAllReferencesOnRuntimeImportWithPaths1.baseline.jsonc @@ -0,0 +1,3 @@ +// === findAllReferences === +// === /project/src/foo.ts === +// import * as x from /*FIND ALL REFS*/"[|tslib|]"; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt b/testdata/baselines/reference/submodule/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt index 47d75a9136..f382004c03 100644 --- a/testdata/baselines/reference/submodule/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt +++ b/testdata/baselines/reference/submodule/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt @@ -2,11 +2,17 @@ argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(3,10): error argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(9,10): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(15,15): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(21,15): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. +argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(33,16): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. +argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(40,7): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. +argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(42,16): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(66,6): error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the 'lib' compiler option to es2015 or later. argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(75,7): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. +argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(77,9): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. +argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(96,26): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. +argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(102,15): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. -==== argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts (6 errors) ==== +==== argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts (12 errors) ==== function A() { return class T { a = arguments @@ -48,6 +54,8 @@ argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(75,7): error function D() { return class T { a = () => arguments // should error + ~~~~~~~~~ +!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. } } @@ -55,8 +63,12 @@ argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(75,7): error return class T { a = () => { arguments; // should error + ~~~~~~~~~ +!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. const b = () => { return arguments; // should error + ~~~~~~~~~ +!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. } function f() { @@ -96,6 +108,8 @@ argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(75,7): error !!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. while(1) { arguments // should error + ~~~~~~~~~ +!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. } } } @@ -115,12 +129,16 @@ argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(75,7): error function D5() { return class T { a = (() => { return arguments; })() // should error + ~~~~~~~~~ +!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. } } function D6() { return class T { a = (x = arguments) => {} // should error + ~~~~~~~~~ +!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. } } diff --git a/testdata/baselines/reference/submodule/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt.diff b/testdata/baselines/reference/submodule/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt.diff deleted file mode 100644 index e541265802..0000000000 --- a/testdata/baselines/reference/submodule/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt.diff +++ /dev/null @@ -1,71 +0,0 @@ ---- old.argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt -+++ new.argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt -@@= skipped -1, +1 lines =@@ - argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(9,10): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. - argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(15,15): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. - argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(21,15): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. --argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(33,16): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. --argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(40,7): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. --argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(42,16): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. - argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(66,6): error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the 'lib' compiler option to es2015 or later. - argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(75,7): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. --argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(77,9): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. --argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(96,26): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. --argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(102,15): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. -- -- --==== argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts (12 errors) ==== -+ -+ -+==== argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts (6 errors) ==== - function A() { - return class T { - a = arguments -@@= skipped -52, +46 lines =@@ - function D() { - return class T { - a = () => arguments // should error -- ~~~~~~~~~ --!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. - } - } - -@@= skipped -9, +7 lines =@@ - return class T { - a = () => { - arguments; // should error -- ~~~~~~~~~ --!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. - const b = () => { - return arguments; // should error -- ~~~~~~~~~ --!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. - } - - function f() { -@@= skipped -45, +41 lines =@@ - !!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. - while(1) { - arguments // should error -- ~~~~~~~~~ --!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. - } - } - } -@@= skipped -21, +19 lines =@@ - function D5() { - return class T { - a = (() => { return arguments; })() // should error -- ~~~~~~~~~ --!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. - } - } - - function D6() { - return class T { - a = (x = arguments) => {} // should error -- ~~~~~~~~~ --!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. - } - } - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.types b/testdata/baselines/reference/submodule/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.types index 2a09231ab2..6d0798d90a 100644 --- a/testdata/baselines/reference/submodule/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.types +++ b/testdata/baselines/reference/submodule/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.types @@ -81,9 +81,9 @@ function D() { >T : typeof T a = () => arguments // should error ->a : () => IArguments ->() => arguments : () => IArguments ->arguments : IArguments +>a : () => any +>() => arguments : () => any +>arguments : any } } @@ -99,14 +99,14 @@ function D1() { >() => { arguments; // should error const b = () => { return arguments; // should error } function f() { return arguments; // ok } } : () => void arguments; // should error ->arguments : IArguments +>arguments : any const b = () => { ->b : () => IArguments ->() => { return arguments; // should error } : () => IArguments +>b : () => any +>() => { return arguments; // should error } : () => any return arguments; // should error ->arguments : IArguments +>arguments : any } function f() { @@ -175,7 +175,7 @@ function D3() { >1 : 1 arguments // should error ->arguments : IArguments +>arguments : any } } } @@ -208,11 +208,11 @@ function D5() { >T : typeof T a = (() => { return arguments; })() // should error ->a : IArguments ->(() => { return arguments; })() : IArguments ->(() => { return arguments; }) : () => IArguments ->() => { return arguments; } : () => IArguments ->arguments : IArguments +>a : any +>(() => { return arguments; })() : any +>(() => { return arguments; }) : () => any +>() => { return arguments; } : () => any +>arguments : any } } @@ -224,10 +224,10 @@ function D6() { >T : typeof T a = (x = arguments) => {} // should error ->a : (x?: IArguments) => void ->(x = arguments) => {} : (x?: IArguments) => void ->x : IArguments ->arguments : IArguments +>a : (x?: any) => void +>(x = arguments) => {} : (x?: any) => void +>x : any +>arguments : any } } diff --git a/testdata/baselines/reference/submodule/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.types.diff b/testdata/baselines/reference/submodule/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.types.diff index 5df6e3a49d..e820f62202 100644 --- a/testdata/baselines/reference/submodule/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.types.diff +++ b/testdata/baselines/reference/submodule/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.types.diff @@ -1,11 +1,65 @@ --- old.argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.types +++ new.argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.types -@@= skipped -174, +174 lines =@@ - >1 : 1 +@@= skipped -80, +80 lines =@@ + >T : typeof T - arguments // should error -->arguments : any -+>arguments : IArguments + a = () => arguments // should error +->a : () => IArguments +->() => arguments : () => IArguments +->arguments : IArguments ++>a : () => any ++>() => arguments : () => any ++>arguments : any + } + } + +@@= skipped -18, +18 lines =@@ + >() => { arguments; // should error const b = () => { return arguments; // should error } function f() { return arguments; // ok } } : () => void + + arguments; // should error +->arguments : IArguments ++>arguments : any + + const b = () => { +->b : () => IArguments +->() => { return arguments; // should error } : () => IArguments ++>b : () => any ++>() => { return arguments; // should error } : () => any + + return arguments; // should error +->arguments : IArguments ++>arguments : any } - } - } \ No newline at end of file + + function f() { +@@= skipped -109, +109 lines =@@ + >T : typeof T + + a = (() => { return arguments; })() // should error +->a : IArguments +->(() => { return arguments; })() : IArguments +->(() => { return arguments; }) : () => IArguments +->() => { return arguments; } : () => IArguments +->arguments : IArguments ++>a : any ++>(() => { return arguments; })() : any ++>(() => { return arguments; }) : () => any ++>() => { return arguments; } : () => any ++>arguments : any + } + } + +@@= skipped -16, +16 lines =@@ + >T : typeof T + + a = (x = arguments) => {} // should error +->a : (x?: IArguments) => void +->(x = arguments) => {} : (x?: IArguments) => void +->x : IArguments +->arguments : IArguments ++>a : (x?: any) => void ++>(x = arguments) => {} : (x?: any) => void ++>x : any ++>arguments : any + } + } diff --git a/testdata/baselines/reference/submodule/compiler/assignmentToConditionalBrandedStringTemplateOrMapping.errors.txt b/testdata/baselines/reference/submodule/compiler/assignmentToConditionalBrandedStringTemplateOrMapping.errors.txt deleted file mode 100644 index ba0ef1ca15..0000000000 --- a/testdata/baselines/reference/submodule/compiler/assignmentToConditionalBrandedStringTemplateOrMapping.errors.txt +++ /dev/null @@ -1,31 +0,0 @@ -assignmentToConditionalBrandedStringTemplateOrMapping.ts(4,1): error TS2719: Type '() => T extends `${"a" & { a: 1; }}` ? 1 : 2' is not assignable to type '() => T extends `${"a" & { a: 1; }}` ? 1 : 2'. Two different types with this name exist, but they are unrelated. - Type 'T extends `${"a" & { a: 1; }}` ? 1 : 2' is not assignable to type 'T extends `${"a" & { a: 1; }}` ? 1 : 2'. Two different types with this name exist, but they are unrelated. - Type '1 | 2' is not assignable to type 'T extends `${"a" & { a: 1; }}` ? 1 : 2'. - Type '1' is not assignable to type 'T extends `${"a" & { a: 1; }}` ? 1 : 2'. -assignmentToConditionalBrandedStringTemplateOrMapping.ts(9,1): error TS2719: Type '() => T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2' is not assignable to type '() => T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2'. Two different types with this name exist, but they are unrelated. - Type 'T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2' is not assignable to type 'T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2'. Two different types with this name exist, but they are unrelated. - Type '1 | 2' is not assignable to type 'T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2'. - Type '1' is not assignable to type 'T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2'. - - -==== assignmentToConditionalBrandedStringTemplateOrMapping.ts (2 errors) ==== - let a: (() => T extends `${'a' & { a: 1 }}` ? 1 : 2) = null!; - let b: (() => T extends `${'a' & { a: 1 }}` ? 1 : 2) = null!; - - a = b; - ~ -!!! error TS2719: Type '() => T extends `${"a" & { a: 1; }}` ? 1 : 2' is not assignable to type '() => T extends `${"a" & { a: 1; }}` ? 1 : 2'. Two different types with this name exist, but they are unrelated. -!!! error TS2719: Type 'T extends `${"a" & { a: 1; }}` ? 1 : 2' is not assignable to type 'T extends `${"a" & { a: 1; }}` ? 1 : 2'. Two different types with this name exist, but they are unrelated. -!!! error TS2719: Type '1 | 2' is not assignable to type 'T extends `${"a" & { a: 1; }}` ? 1 : 2'. -!!! error TS2719: Type '1' is not assignable to type 'T extends `${"a" & { a: 1; }}` ? 1 : 2'. - - let c: (() => T extends Uppercase<'a' & { a: 1 }> ? 1 : 2) = null!; - let d: (() => T extends Uppercase<'a' & { a: 1 }> ? 1 : 2) = null!; - - c = d; - ~ -!!! error TS2719: Type '() => T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2' is not assignable to type '() => T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2'. Two different types with this name exist, but they are unrelated. -!!! error TS2719: Type 'T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2' is not assignable to type 'T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2'. Two different types with this name exist, but they are unrelated. -!!! error TS2719: Type '1 | 2' is not assignable to type 'T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2'. -!!! error TS2719: Type '1' is not assignable to type 'T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2'. - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/assignmentToConditionalBrandedStringTemplateOrMapping.errors.txt.diff b/testdata/baselines/reference/submodule/compiler/assignmentToConditionalBrandedStringTemplateOrMapping.errors.txt.diff deleted file mode 100644 index ff7b747ff9..0000000000 --- a/testdata/baselines/reference/submodule/compiler/assignmentToConditionalBrandedStringTemplateOrMapping.errors.txt.diff +++ /dev/null @@ -1,35 +0,0 @@ ---- old.assignmentToConditionalBrandedStringTemplateOrMapping.errors.txt -+++ new.assignmentToConditionalBrandedStringTemplateOrMapping.errors.txt -@@= skipped -0, +0 lines =@@ -- -+assignmentToConditionalBrandedStringTemplateOrMapping.ts(4,1): error TS2719: Type '() => T extends `${"a" & { a: 1; }}` ? 1 : 2' is not assignable to type '() => T extends `${"a" & { a: 1; }}` ? 1 : 2'. Two different types with this name exist, but they are unrelated. -+ Type 'T extends `${"a" & { a: 1; }}` ? 1 : 2' is not assignable to type 'T extends `${"a" & { a: 1; }}` ? 1 : 2'. Two different types with this name exist, but they are unrelated. -+ Type '1 | 2' is not assignable to type 'T extends `${"a" & { a: 1; }}` ? 1 : 2'. -+ Type '1' is not assignable to type 'T extends `${"a" & { a: 1; }}` ? 1 : 2'. -+assignmentToConditionalBrandedStringTemplateOrMapping.ts(9,1): error TS2719: Type '() => T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2' is not assignable to type '() => T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2'. Two different types with this name exist, but they are unrelated. -+ Type 'T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2' is not assignable to type 'T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2'. Two different types with this name exist, but they are unrelated. -+ Type '1 | 2' is not assignable to type 'T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2'. -+ Type '1' is not assignable to type 'T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2'. -+ -+ -+==== assignmentToConditionalBrandedStringTemplateOrMapping.ts (2 errors) ==== -+ let a: (() => T extends `${'a' & { a: 1 }}` ? 1 : 2) = null!; -+ let b: (() => T extends `${'a' & { a: 1 }}` ? 1 : 2) = null!; -+ -+ a = b; -+ ~ -+!!! error TS2719: Type '() => T extends `${"a" & { a: 1; }}` ? 1 : 2' is not assignable to type '() => T extends `${"a" & { a: 1; }}` ? 1 : 2'. Two different types with this name exist, but they are unrelated. -+!!! error TS2719: Type 'T extends `${"a" & { a: 1; }}` ? 1 : 2' is not assignable to type 'T extends `${"a" & { a: 1; }}` ? 1 : 2'. Two different types with this name exist, but they are unrelated. -+!!! error TS2719: Type '1 | 2' is not assignable to type 'T extends `${"a" & { a: 1; }}` ? 1 : 2'. -+!!! error TS2719: Type '1' is not assignable to type 'T extends `${"a" & { a: 1; }}` ? 1 : 2'. -+ -+ let c: (() => T extends Uppercase<'a' & { a: 1 }> ? 1 : 2) = null!; -+ let d: (() => T extends Uppercase<'a' & { a: 1 }> ? 1 : 2) = null!; -+ -+ c = d; -+ ~ -+!!! error TS2719: Type '() => T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2' is not assignable to type '() => T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2'. Two different types with this name exist, but they are unrelated. -+!!! error TS2719: Type 'T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2' is not assignable to type 'T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2'. Two different types with this name exist, but they are unrelated. -+!!! error TS2719: Type '1 | 2' is not assignable to type 'T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2'. -+!!! error TS2719: Type '1' is not assignable to type 'T extends Uppercase<`${"a" & { a: 1; }}`> ? 1 : 2'. -+ \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/bigintAmbientMinimal.errors.txt b/testdata/baselines/reference/submodule/compiler/bigintAmbientMinimal.errors.txt index d7dc0ab5eb..e95b511da0 100644 --- a/testdata/baselines/reference/submodule/compiler/bigintAmbientMinimal.errors.txt +++ b/testdata/baselines/reference/submodule/compiler/bigintAmbientMinimal.errors.txt @@ -1,24 +1,15 @@ -/ambient.d.ts(1,25): error TS2737: BigInt literals are not available when targeting lower than ES2020. -/ambient.d.ts(3,19): error TS2737: BigInt literals are not available when targeting lower than ES2020. -/main.ts(2,19): error TS2737: BigInt literals are not available when targeting lower than ES2020. /main.ts(5,17): error TS2737: BigInt literals are not available when targeting lower than ES2020. -==== /ambient.d.ts (2 errors) ==== +==== /ambient.d.ts (0 errors) ==== declare const fromDts = 789n; - ~~~~ -!!! error TS2737: BigInt literals are not available when targeting lower than ES2020. declare namespace Lib { const value = 999n; - ~~~~ -!!! error TS2737: BigInt literals are not available when targeting lower than ES2020. } -==== /main.ts (2 errors) ==== +==== /main.ts (1 errors) ==== // Minimal repro from issue declare const n = 123n; - ~~~~ -!!! error TS2737: BigInt literals are not available when targeting lower than ES2020. // Non-ambient for comparison const regular = 456n; diff --git a/testdata/baselines/reference/submodule/compiler/bigintAmbientMinimal.errors.txt.diff b/testdata/baselines/reference/submodule/compiler/bigintAmbientMinimal.errors.txt.diff deleted file mode 100644 index 4e42f9dea2..0000000000 --- a/testdata/baselines/reference/submodule/compiler/bigintAmbientMinimal.errors.txt.diff +++ /dev/null @@ -1,29 +0,0 @@ ---- old.bigintAmbientMinimal.errors.txt -+++ new.bigintAmbientMinimal.errors.txt -@@= skipped -0, +0 lines =@@ -+/ambient.d.ts(1,25): error TS2737: BigInt literals are not available when targeting lower than ES2020. -+/ambient.d.ts(3,19): error TS2737: BigInt literals are not available when targeting lower than ES2020. -+/main.ts(2,19): error TS2737: BigInt literals are not available when targeting lower than ES2020. - /main.ts(5,17): error TS2737: BigInt literals are not available when targeting lower than ES2020. - - --==== /ambient.d.ts (0 errors) ==== -+==== /ambient.d.ts (2 errors) ==== - declare const fromDts = 789n; -+ ~~~~ -+!!! error TS2737: BigInt literals are not available when targeting lower than ES2020. - declare namespace Lib { - const value = 999n; -+ ~~~~ -+!!! error TS2737: BigInt literals are not available when targeting lower than ES2020. - } - --==== /main.ts (1 errors) ==== -+==== /main.ts (2 errors) ==== - // Minimal repro from issue - declare const n = 123n; -+ ~~~~ -+!!! error TS2737: BigInt literals are not available when targeting lower than ES2020. - - // Non-ambient for comparison - const regular = 456n; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/blockScopedVariablesUseBeforeDef.errors.txt b/testdata/baselines/reference/submodule/compiler/blockScopedVariablesUseBeforeDef.errors.txt index 8995ac009c..7beb2b37b9 100644 --- a/testdata/baselines/reference/submodule/compiler/blockScopedVariablesUseBeforeDef.errors.txt +++ b/testdata/baselines/reference/submodule/compiler/blockScopedVariablesUseBeforeDef.errors.txt @@ -5,9 +5,12 @@ blockScopedVariablesUseBeforeDef.ts(100,12): error TS2448: Block-scoped variable blockScopedVariablesUseBeforeDef.ts(111,28): error TS2448: Block-scoped variable 'a' used before its declaration. blockScopedVariablesUseBeforeDef.ts(112,21): error TS2448: Block-scoped variable 'a' used before its declaration. blockScopedVariablesUseBeforeDef.ts(122,22): error TS2448: Block-scoped variable 'a' used before its declaration. +blockScopedVariablesUseBeforeDef.ts(128,9): error TS2448: Block-scoped variable 'foo' used before its declaration. +blockScopedVariablesUseBeforeDef.ts(131,9): error TS2448: Block-scoped variable 'foo' used before its declaration. +blockScopedVariablesUseBeforeDef.ts(153,20): error TS2450: Enum 'Enum' used before its declaration. -==== blockScopedVariablesUseBeforeDef.ts (7 errors) ==== +==== blockScopedVariablesUseBeforeDef.ts (10 errors) ==== function foo0() { let a = x; ~ @@ -157,9 +160,15 @@ blockScopedVariablesUseBeforeDef.ts(122,22): error TS2448: Block-scoped variable const promise = (async () => { promise foo + ~~~ +!!! error TS2448: Block-scoped variable 'foo' used before its declaration. +!!! related TS2728 blockScopedVariablesUseBeforeDef.ts:134:11: 'foo' is declared here. await null promise foo + ~~~ +!!! error TS2448: Block-scoped variable 'foo' used before its declaration. +!!! related TS2728 blockScopedVariablesUseBeforeDef.ts:134:11: 'foo' is declared here. })() const foo = 1; @@ -182,6 +191,9 @@ blockScopedVariablesUseBeforeDef.ts(122,22): error TS2448: Block-scoped variable function foo18() { let a = (() => Enum.Yes)(); + ~~~~ +!!! error TS2450: Enum 'Enum' used before its declaration. +!!! related TS2728 blockScopedVariablesUseBeforeDef.ts:154:10: 'Enum' is declared here. enum Enum { No = 0, Yes = 1, diff --git a/testdata/baselines/reference/submodule/compiler/blockScopedVariablesUseBeforeDef.errors.txt.diff b/testdata/baselines/reference/submodule/compiler/blockScopedVariablesUseBeforeDef.errors.txt.diff deleted file mode 100644 index b610dff2c5..0000000000 --- a/testdata/baselines/reference/submodule/compiler/blockScopedVariablesUseBeforeDef.errors.txt.diff +++ /dev/null @@ -1,44 +0,0 @@ ---- old.blockScopedVariablesUseBeforeDef.errors.txt -+++ new.blockScopedVariablesUseBeforeDef.errors.txt -@@= skipped -4, +4 lines =@@ - blockScopedVariablesUseBeforeDef.ts(111,28): error TS2448: Block-scoped variable 'a' used before its declaration. - blockScopedVariablesUseBeforeDef.ts(112,21): error TS2448: Block-scoped variable 'a' used before its declaration. - blockScopedVariablesUseBeforeDef.ts(122,22): error TS2448: Block-scoped variable 'a' used before its declaration. --blockScopedVariablesUseBeforeDef.ts(128,9): error TS2448: Block-scoped variable 'foo' used before its declaration. --blockScopedVariablesUseBeforeDef.ts(131,9): error TS2448: Block-scoped variable 'foo' used before its declaration. --blockScopedVariablesUseBeforeDef.ts(153,20): error TS2450: Enum 'Enum' used before its declaration. -- -- --==== blockScopedVariablesUseBeforeDef.ts (10 errors) ==== -+ -+ -+==== blockScopedVariablesUseBeforeDef.ts (7 errors) ==== - function foo0() { - let a = x; - ~ -@@= skipped -155, +152 lines =@@ - const promise = (async () => { - promise - foo -- ~~~ --!!! error TS2448: Block-scoped variable 'foo' used before its declaration. --!!! related TS2728 blockScopedVariablesUseBeforeDef.ts:134:11: 'foo' is declared here. - await null - promise - foo -- ~~~ --!!! error TS2448: Block-scoped variable 'foo' used before its declaration. --!!! related TS2728 blockScopedVariablesUseBeforeDef.ts:134:11: 'foo' is declared here. - })() - - const foo = 1; -@@= skipped -31, +25 lines =@@ - - function foo18() { - let a = (() => Enum.Yes)(); -- ~~~~ --!!! error TS2450: Enum 'Enum' used before its declaration. --!!! related TS2728 blockScopedVariablesUseBeforeDef.ts:154:10: 'Enum' is declared here. - enum Enum { - No = 0, - Yes = 1, \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/computedTypesKeyofNoIndexSignatureType.types b/testdata/baselines/reference/submodule/compiler/computedTypesKeyofNoIndexSignatureType.types index daae4f44f8..fac9a0142b 100644 --- a/testdata/baselines/reference/submodule/compiler/computedTypesKeyofNoIndexSignatureType.types +++ b/testdata/baselines/reference/submodule/compiler/computedTypesKeyofNoIndexSignatureType.types @@ -2,7 +2,7 @@ === computedTypesKeyofNoIndexSignatureType.ts === type Compute = { [K in keyof A]: Compute; } & {}; ->Compute : { [K in keyof A]: A[K_1] extends infer T extends unknown ? { [K in keyof T]: A[K_1][K_2] extends infer T extends unknown ? { [K in keyof T]: A[K_1][K_2][K_3] extends infer T extends unknown ? { [K in keyof T]: A[K_1][K_2][K_3][K_4] extends infer T extends unknown ? { [K in keyof T]: A[K_1][K_2][K_3][K_4][K_5] extends infer T extends unknown ? { [K in keyof T]: A[K_1][K_2][K_3][K_4][K_5][K_6] extends infer T extends unknown ? { [K in keyof T]: A[K_1][K_2][K_3][K_4][K_5][K_6][K_7] extends infer T extends unknown ? { [K in keyof T]: A[K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8] extends infer T extends unknown ? { [K in keyof T]: A[K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8][K_9] extends infer T extends unknown ? { [K in keyof T]: A[K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8][K_9][K_10] extends infer T extends unknown ? { [K in keyof T]: any; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } +>Compute : { [K in keyof A]: A[K] extends infer T ? { [K_1 in keyof T]: T[K_1] extends infer T_1 ? { [K_2 in keyof T_1]: T_1[K_2] extends infer T_2 ? { [K_3 in keyof T_2]: T_2[K_3] extends infer T_3 ? { [K_4 in keyof T_3]: T_3[K_4] extends infer T_4 ? { [K_5 in keyof T_4]: T_4[K_5] extends infer T_5 ? { [K_6 in keyof T_5]: T_5[K_6] extends infer T_6 ? { [K_7 in keyof T_6]: T_6[K_7] extends infer T_7 ? { [K_8 in keyof T_7]: T_7[K_8] extends infer T_8 ? { [K_9 in keyof T_8]: T_8[K_9] extends infer T_9 ? { [K_10 in keyof T_9]: any; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } type EqualsTest = () => A extends T ? 1 : 0; >EqualsTest : EqualsTest diff --git a/testdata/baselines/reference/submodule/compiler/computedTypesKeyofNoIndexSignatureType.types.diff b/testdata/baselines/reference/submodule/compiler/computedTypesKeyofNoIndexSignatureType.types.diff deleted file mode 100644 index 2b68cafef0..0000000000 --- a/testdata/baselines/reference/submodule/compiler/computedTypesKeyofNoIndexSignatureType.types.diff +++ /dev/null @@ -1,11 +0,0 @@ ---- old.computedTypesKeyofNoIndexSignatureType.types -+++ new.computedTypesKeyofNoIndexSignatureType.types -@@= skipped -1, +1 lines =@@ - - === computedTypesKeyofNoIndexSignatureType.ts === - type Compute = { [K in keyof A]: Compute; } & {}; -->Compute : { [K in keyof A]: A[K] extends infer T ? { [K_1 in keyof T]: T[K_1] extends infer T_1 ? { [K_2 in keyof T_1]: T_1[K_2] extends infer T_2 ? { [K_3 in keyof T_2]: T_2[K_3] extends infer T_3 ? { [K_4 in keyof T_3]: T_3[K_4] extends infer T_4 ? { [K_5 in keyof T_4]: T_4[K_5] extends infer T_5 ? { [K_6 in keyof T_5]: T_5[K_6] extends infer T_6 ? { [K_7 in keyof T_6]: T_6[K_7] extends infer T_7 ? { [K_8 in keyof T_7]: T_7[K_8] extends infer T_8 ? { [K_9 in keyof T_8]: T_8[K_9] extends infer T_9 ? { [K_10 in keyof T_9]: any; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } -+>Compute : { [K in keyof A]: A[K_1] extends infer T extends unknown ? { [K in keyof T]: A[K_1][K_2] extends infer T extends unknown ? { [K in keyof T]: A[K_1][K_2][K_3] extends infer T extends unknown ? { [K in keyof T]: A[K_1][K_2][K_3][K_4] extends infer T extends unknown ? { [K in keyof T]: A[K_1][K_2][K_3][K_4][K_5] extends infer T extends unknown ? { [K in keyof T]: A[K_1][K_2][K_3][K_4][K_5][K_6] extends infer T extends unknown ? { [K in keyof T]: A[K_1][K_2][K_3][K_4][K_5][K_6][K_7] extends infer T extends unknown ? { [K in keyof T]: A[K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8] extends infer T extends unknown ? { [K in keyof T]: A[K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8][K_9] extends infer T extends unknown ? { [K in keyof T]: A[K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8][K_9][K_10] extends infer T extends unknown ? { [K in keyof T]: any; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } - - type EqualsTest = () => A extends T ? 1 : 0; - >EqualsTest : EqualsTest \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/declarationEmitGenericTypeParamerSerialization3.js b/testdata/baselines/reference/submodule/compiler/declarationEmitGenericTypeParamerSerialization3.js index 519c94d037..172ee40b11 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationEmitGenericTypeParamerSerialization3.js +++ b/testdata/baselines/reference/submodule/compiler/declarationEmitGenericTypeParamerSerialization3.js @@ -36,11 +36,13 @@ export const Cls = wrapper("test"); //// [declarationEmitGenericTypeParamerSerialization3.d.ts] export declare function wrapper(value: T): { new (): { - name: T; + get name(): T; + set name(arg: T); }; }; export declare const Cls: { new (): { - name: string; + get name(): string; + set name(arg: string); }; }; diff --git a/testdata/baselines/reference/submodule/compiler/declarationEmitGenericTypeParamerSerialization3.js.diff b/testdata/baselines/reference/submodule/compiler/declarationEmitGenericTypeParamerSerialization3.js.diff deleted file mode 100644 index 8cb65f8e28..0000000000 --- a/testdata/baselines/reference/submodule/compiler/declarationEmitGenericTypeParamerSerialization3.js.diff +++ /dev/null @@ -1,18 +0,0 @@ ---- old.declarationEmitGenericTypeParamerSerialization3.js -+++ new.declarationEmitGenericTypeParamerSerialization3.js -@@= skipped -35, +35 lines =@@ - //// [declarationEmitGenericTypeParamerSerialization3.d.ts] - export declare function wrapper(value: T): { - new (): { -- get name(): T; -- set name(arg: T); -+ name: T; - }; - }; - export declare const Cls: { - new (): { -- get name(): string; -- set name(arg: string); -+ name: string; - }; - }; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypeDistributivityPreservesConstraints.js b/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypeDistributivityPreservesConstraints.js index 736c247093..62c571420a 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypeDistributivityPreservesConstraints.js +++ b/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypeDistributivityPreservesConstraints.js @@ -50,50 +50,12 @@ export default _default; declare const _default: { test: { fn: (sliceIndex: T) => T["x"] extends infer T_1 ? { [K in keyof T_1]: Parameters; } : never; + x: T["x"] extends infer T_1 extends { + [x: string]: (...params: unknown[]) => unknown; + } ? { [K in keyof T_1]: T_1[K]; } : never; + }>(sliceIndex: T) => T["x"] extends infer T_2 extends { + [x: string]: (...params: unknown[]) => unknown; + } ? { [K in keyof T_2]: Parameters; } : never; }; }; export default _default; - - -//// [DtsFileErrors] - - -reexport.d.ts(5,88): error TS2344: Type 'T["x"][K]' does not satisfy the constraint '(...args: any) => any'. - Type 'T["x"][keyof T_1]' is not assignable to type '(...args: any) => any'. - Type 'T["x"][string] | T["x"][number] | T["x"][symbol]' is not assignable to type '(...args: any) => any'. - Type 'T["x"][string]' is not assignable to type '(...args: any) => any'. - - -==== types.d.ts (0 errors) ==== - type Fns = Record unknown>; - type Map = { - [K in keyof T]: T[K]; - }; - type AllArg = { - [K in keyof T]: Parameters; - }; - declare function fn; - }>(sliceIndex: T): AllArg; - declare const _default: { - fn: typeof fn; - }; - export default _default; - -==== reexport.d.ts (1 errors) ==== - declare const _default: { - test: { - fn: (sliceIndex: T) => T["x"] extends infer T_1 ? { [K in keyof T_1]: Parameters; } : never; - ~~~~~~~~~ -!!! error TS2344: Type 'T["x"][K]' does not satisfy the constraint '(...args: any) => any'. -!!! error TS2344: Type 'T["x"][keyof T_1]' is not assignable to type '(...args: any) => any'. -!!! error TS2344: Type 'T["x"][string] | T["x"][number] | T["x"][symbol]' is not assignable to type '(...args: any) => any'. -!!! error TS2344: Type 'T["x"][string]' is not assignable to type '(...args: any) => any'. - }; - }; - export default _default; - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypeDistributivityPreservesConstraints.js.diff b/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypeDistributivityPreservesConstraints.js.diff index 70deef9e58..42e8128dfa 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypeDistributivityPreservesConstraints.js.diff +++ b/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypeDistributivityPreservesConstraints.js.diff @@ -9,60 +9,12 @@ exports.default = { test: types_1.default }; -@@= skipped -23, +23 lines =@@ - declare const _default: { - test: { - fn: unknown; -- } ? { [K in keyof T_1]: T_1[K]; } : never; -- }>(sliceIndex: T) => T["x"] extends infer T_2 extends { -- [x: string]: (...params: unknown[]) => unknown; +@@= skipped -28, +28 lines =@@ + } ? { [K in keyof T_1]: T_1[K]; } : never; + }>(sliceIndex: T) => T["x"] extends infer T_2 extends { + [x: string]: (...params: unknown[]) => unknown; - } ? { [K_1 in keyof T_2]: Parameters; } : never; -+ x: T["x"] extends infer T_1 ? { [K in keyof T_1]: T["x"][K]; } : never; -+ }>(sliceIndex: T) => T["x"] extends infer T_1 ? { [K in keyof T_1]: Parameters; } : never; ++ } ? { [K in keyof T_2]: Parameters; } : never; }; }; - export default _default; -+ -+ -+//// [DtsFileErrors] -+ -+ -+reexport.d.ts(5,88): error TS2344: Type 'T["x"][K]' does not satisfy the constraint '(...args: any) => any'. -+ Type 'T["x"][keyof T_1]' is not assignable to type '(...args: any) => any'. -+ Type 'T["x"][string] | T["x"][number] | T["x"][symbol]' is not assignable to type '(...args: any) => any'. -+ Type 'T["x"][string]' is not assignable to type '(...args: any) => any'. -+ -+ -+==== types.d.ts (0 errors) ==== -+ type Fns = Record unknown>; -+ type Map = { -+ [K in keyof T]: T[K]; -+ }; -+ type AllArg = { -+ [K in keyof T]: Parameters; -+ }; -+ declare function fn; -+ }>(sliceIndex: T): AllArg; -+ declare const _default: { -+ fn: typeof fn; -+ }; -+ export default _default; -+ -+==== reexport.d.ts (1 errors) ==== -+ declare const _default: { -+ test: { -+ fn: (sliceIndex: T) => T["x"] extends infer T_1 ? { [K in keyof T_1]: Parameters; } : never; -+ ~~~~~~~~~ -+!!! error TS2344: Type 'T["x"][K]' does not satisfy the constraint '(...args: any) => any'. -+!!! error TS2344: Type 'T["x"][keyof T_1]' is not assignable to type '(...args: any) => any'. -+!!! error TS2344: Type 'T["x"][string] | T["x"][number] | T["x"][symbol]' is not assignable to type '(...args: any) => any'. -+!!! error TS2344: Type 'T["x"][string]' is not assignable to type '(...args: any) => any'. -+ }; -+ }; -+ export default _default; -+ \ No newline at end of file + export default _default; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypeDistributivityPreservesConstraints.types b/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypeDistributivityPreservesConstraints.types index 96e4a14d96..a8a5ea57ec 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypeDistributivityPreservesConstraints.types +++ b/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypeDistributivityPreservesConstraints.types @@ -26,9 +26,9 @@ export default { fn }; === reexport.ts === import test from "./types"; ->test : { fn: (sliceIndex: T) => T["x"] extends infer T_1 ? { [K in keyof T_1]: Parameters; } : never; } +>test : { fn: unknown; } ? { [K in keyof T_1]: T_1[K]; } : never; }>(sliceIndex: T) => T["x"] extends infer T_2 extends { [x: string]: (...params: unknown[]) => unknown; } ? { [K in keyof T_2]: Parameters; } : never; } export default { test }; ->{ test } : { test: { fn: (sliceIndex: T) => T["x"] extends infer T_1 ? { [K in keyof T_1]: Parameters; } : never; }; } ->test : { fn: (sliceIndex: T) => T["x"] extends infer T_1 ? { [K in keyof T_1]: Parameters; } : never; } +>{ test } : { test: { fn: unknown; } ? { [K in keyof T_1]: T_1[K]; } : never; }>(sliceIndex: T) => T["x"] extends infer T_2 extends { [x: string]: (...params: unknown[]) => unknown; } ? { [K in keyof T_2]: Parameters; } : never; }; } +>test : { fn: unknown; } ? { [K in keyof T_1]: T_1[K]; } : never; }>(sliceIndex: T) => T["x"] extends infer T_2 extends { [x: string]: (...params: unknown[]) => unknown; } ? { [K in keyof T_2]: Parameters; } : never; } diff --git a/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypeDistributivityPreservesConstraints.types.diff b/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypeDistributivityPreservesConstraints.types.diff index edf2249aa7..5e519d4701 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypeDistributivityPreservesConstraints.types.diff +++ b/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypeDistributivityPreservesConstraints.types.diff @@ -5,10 +5,10 @@ === reexport.ts === import test from "./types"; ->test : { fn: unknown; } ? { [K in keyof T_1]: T_1[K]; } : never; }>(sliceIndex: T) => T["x"] extends infer T_2 extends { [x: string]: (...params: unknown[]) => unknown; } ? { [K_1 in keyof T_2]: Parameters; } : never; } -+>test : { fn: (sliceIndex: T) => T["x"] extends infer T_1 ? { [K in keyof T_1]: Parameters; } : never; } ++>test : { fn: unknown; } ? { [K in keyof T_1]: T_1[K]; } : never; }>(sliceIndex: T) => T["x"] extends infer T_2 extends { [x: string]: (...params: unknown[]) => unknown; } ? { [K in keyof T_2]: Parameters; } : never; } export default { test }; ->{ test } : { test: { fn: unknown; } ? { [K in keyof T_1]: T_1[K]; } : never; }>(sliceIndex: T) => T["x"] extends infer T_2 extends { [x: string]: (...params: unknown[]) => unknown; } ? { [K_1 in keyof T_2]: Parameters; } : never; }; } ->test : { fn: unknown; } ? { [K in keyof T_1]: T_1[K]; } : never; }>(sliceIndex: T) => T["x"] extends infer T_2 extends { [x: string]: (...params: unknown[]) => unknown; } ? { [K_1 in keyof T_2]: Parameters; } : never; } -+>{ test } : { test: { fn: (sliceIndex: T) => T["x"] extends infer T_1 ? { [K in keyof T_1]: Parameters; } : never; }; } -+>test : { fn: (sliceIndex: T) => T["x"] extends infer T_1 ? { [K in keyof T_1]: Parameters; } : never; } ++>{ test } : { test: { fn: unknown; } ? { [K in keyof T_1]: T_1[K]; } : never; }>(sliceIndex: T) => T["x"] extends infer T_2 extends { [x: string]: (...params: unknown[]) => unknown; } ? { [K in keyof T_2]: Parameters; } : never; }; } ++>test : { fn: unknown; } ? { [K in keyof T_1]: T_1[K]; } : never; }>(sliceIndex: T) => T["x"] extends infer T_2 extends { [x: string]: (...params: unknown[]) => unknown; } ? { [K in keyof T_2]: Parameters; } : never; } diff --git a/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypePreservesTypeParameterConstraint.js b/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypePreservesTypeParameterConstraint.js index 8ec1b82955..43466056a4 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypePreservesTypeParameterConstraint.js +++ b/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypePreservesTypeParameterConstraint.js @@ -94,9 +94,7 @@ export declare type ZodRawShape = { }; export declare const buildSchema: (version: V) => addQuestionMarks; -}>, undefined extends V ? never : "version"> extends infer T extends unknown ? { [k in keyof T]: addQuestionMarks; -}>, undefined extends V ? never : "version">[k]; } : never; +}>, undefined extends V ? never : "version"> extends infer T ? { [k in keyof T]: T[k]; } : never; type evaluate = { [k in keyof t]: t[k]; } & unknown; @@ -104,57 +102,5 @@ export type entryOf = evaluate<{ [k in keyof o]-?: [k, o[k] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o]>; export type entriesOf = evaluate[]>; -export declare const entriesOf: (o: o) => ({ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T extends unknown ? { [k in keyof T]: { [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o][k]; } : never)[]; +export declare const entriesOf: (o: o) => ({ [k in keyof o]-?: [k, o[k] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T ? { [k in keyof T]: T[k]; } : never)[]; export {}; - - -//// [DtsFileErrors] - - -declarationEmitMappedTypePreservesTypeParameterConstraint.d.ts(24,98): error TS2536: Type 'k' cannot be used to index type 'addQuestionMarks; }>, undefined extends V ? never : "version">'. -declarationEmitMappedTypePreservesTypeParameterConstraint.d.ts(34,226): error TS2536: Type 'k' cannot be used to index type '{ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o]'. - - -==== declarationEmitMappedTypePreservesTypeParameterConstraint.d.ts (2 errors) ==== - declare type requiredKeys = { - [k in keyof T]: undefined extends T[k] ? never : k; - }[keyof T]; - declare type addQuestionMarks> = Pick, R> & Partial; - declare type identity = T; - declare type flatten = identity<{ - [k in keyof T]: T[k]; - }>; - export declare abstract class ZodType { - readonly _output: Output; - } - export declare class ZodLiteral extends ZodType { - } - export declare type ZodTypeAny = ZodType; - export declare type baseObjectOutputType = { - [k in keyof Shape]: Shape[k]["_output"]; - }; - export declare type objectOutputType = flatten>>; - export declare type ZodRawShape = { - [k: string]: ZodTypeAny; - }; - export declare const buildSchema: (version: V) => addQuestionMarks; - }>, undefined extends V ? never : "version"> extends infer T extends unknown ? { [k in keyof T]: addQuestionMarks; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~ - }>, undefined extends V ? never : "version">[k]; } : never; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2536: Type 'k' cannot be used to index type 'addQuestionMarks; }>, undefined extends V ? never : "version">'. - type evaluate = { - [k in keyof t]: t[k]; - } & unknown; - export type entryOf = evaluate<{ - [k in keyof o]-?: [k, o[k] & ({} | null)]; - }[o extends readonly unknown[] ? keyof o & number : keyof o]>; - export type entriesOf = evaluate[]>; - export declare const entriesOf: (o: o) => ({ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T extends unknown ? { [k in keyof T]: { [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o][k]; } : never)[]; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2536: Type 'k' cannot be used to index type '{ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o]'. - export {}; - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypePreservesTypeParameterConstraint.js.diff b/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypePreservesTypeParameterConstraint.js.diff index 4cdbbcd494..90819e98d3 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypePreservesTypeParameterConstraint.js.diff +++ b/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypePreservesTypeParameterConstraint.js.diff @@ -17,72 +17,17 @@ [k: string]: ZodTypeAny; }; -export declare const buildSchema: (version: V) => objectOutputType<{ -- version: ZodLiteral; --}>; +export declare const buildSchema: (version: V) => addQuestionMarks; -+}>, undefined extends V ? never : "version"> extends infer T extends unknown ? { [k in keyof T]: addQuestionMarks; -+}>, undefined extends V ? never : "version">[k]; } : never; + version: ZodLiteral; +-}>; ++}>, undefined extends V ? never : "version"> extends infer T ? { [k in keyof T]: T[k]; } : never; type evaluate = { [k in keyof t]: t[k]; } & unknown; -@@= skipped -10, +12 lines =@@ +@@= skipped -10, +10 lines =@@ [k in keyof o]-?: [k, o[k] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o]>; export type entriesOf = evaluate[]>; -export declare const entriesOf: (o: o) => entriesOf; -+export declare const entriesOf: (o: o) => ({ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T extends unknown ? { [k in keyof T]: { [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o][k]; } : never)[]; - export {}; -+ -+ -+//// [DtsFileErrors] -+ -+ -+declarationEmitMappedTypePreservesTypeParameterConstraint.d.ts(24,98): error TS2536: Type 'k' cannot be used to index type 'addQuestionMarks; }>, undefined extends V ? never : "version">'. -+declarationEmitMappedTypePreservesTypeParameterConstraint.d.ts(34,226): error TS2536: Type 'k' cannot be used to index type '{ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o]'. -+ -+ -+==== declarationEmitMappedTypePreservesTypeParameterConstraint.d.ts (2 errors) ==== -+ declare type requiredKeys = { -+ [k in keyof T]: undefined extends T[k] ? never : k; -+ }[keyof T]; -+ declare type addQuestionMarks> = Pick, R> & Partial; -+ declare type identity = T; -+ declare type flatten = identity<{ -+ [k in keyof T]: T[k]; -+ }>; -+ export declare abstract class ZodType { -+ readonly _output: Output; -+ } -+ export declare class ZodLiteral extends ZodType { -+ } -+ export declare type ZodTypeAny = ZodType; -+ export declare type baseObjectOutputType = { -+ [k in keyof Shape]: Shape[k]["_output"]; -+ }; -+ export declare type objectOutputType = flatten>>; -+ export declare type ZodRawShape = { -+ [k: string]: ZodTypeAny; -+ }; -+ export declare const buildSchema: (version: V) => addQuestionMarks; -+ }>, undefined extends V ? never : "version"> extends infer T extends unknown ? { [k in keyof T]: addQuestionMarks; -+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~ -+ }>, undefined extends V ? never : "version">[k]; } : never; -+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -+!!! error TS2536: Type 'k' cannot be used to index type 'addQuestionMarks; }>, undefined extends V ? never : "version">'. -+ type evaluate = { -+ [k in keyof t]: t[k]; -+ } & unknown; -+ export type entryOf = evaluate<{ -+ [k in keyof o]-?: [k, o[k] & ({} | null)]; -+ }[o extends readonly unknown[] ? keyof o & number : keyof o]>; -+ export type entriesOf = evaluate[]>; -+ export declare const entriesOf: (o: o) => ({ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T extends unknown ? { [k in keyof T]: { [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o][k]; } : never)[]; -+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -+!!! error TS2536: Type 'k' cannot be used to index type '{ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o]'. -+ export {}; -+ \ No newline at end of file ++export declare const entriesOf: (o: o) => ({ [k in keyof o]-?: [k, o[k] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T ? { [k in keyof T]: T[k]; } : never)[]; + export {}; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypePreservesTypeParameterConstraint.types b/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypePreservesTypeParameterConstraint.types index e9a054ef2c..71e84cd1c4 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypePreservesTypeParameterConstraint.types +++ b/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypePreservesTypeParameterConstraint.types @@ -46,7 +46,7 @@ export declare type baseObjectOutputType = { }; export declare type objectOutputType = flatten< ->objectOutputType : addQuestionMarks, requiredKeys>> extends infer T extends unknown ? { [k in keyof T]: addQuestionMarks, requiredKeys>>[k]; } : never +>objectOutputType : addQuestionMarks, requiredKeys>> extends infer T ? { [k in keyof T]: T[k]; } : never addQuestionMarks> >; @@ -60,8 +60,8 @@ export declare type ZodRawShape = { }; export const buildSchema = ( ->buildSchema : (version: V) => addQuestionMarks; }>, undefined extends V ? never : "version"> extends infer T extends unknown ? { [k in keyof T]: addQuestionMarks; }>, undefined extends V ? never : "version">[k]; } : never ->( version: V): objectOutputType<{ version: ZodLiteral;}> => ({} as any) : (version: V) => addQuestionMarks; }>, undefined extends V ? never : "version"> extends infer T extends unknown ? { [k in keyof T]: addQuestionMarks; }>, undefined extends V ? never : "version">[k]; } : never +>buildSchema : (version: V) => addQuestionMarks; }>, undefined extends V ? never : "version"> extends infer T ? { [k in keyof T]: T[k]; } : never +>( version: V): objectOutputType<{ version: ZodLiteral;}> => ({} as any) : (version: V) => addQuestionMarks; }>, undefined extends V ? never : "version"> extends infer T ? { [k in keyof T]: T[k]; } : never version: V >version : V @@ -81,7 +81,7 @@ type evaluate = { [k in keyof t]: t[k] } & unknown >evaluate : { [k in keyof t]: t[k]; } export type entryOf = evaluate< ->entryOf : { [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T extends unknown ? { [k in keyof T]: { [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o][k]; } : never +>entryOf : { [k in keyof o]-?: [k, o[k] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T ? { [k in keyof T]: T[k]; } : never { [k in keyof o]-?: [k, o[k] & ({} | null)] }[o extends readonly unknown[] ? keyof o & number @@ -89,15 +89,15 @@ export type entryOf = evaluate< > export type entriesOf = evaluate[]> ->entriesOf : ({ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T extends unknown ? { [k in keyof T]: { [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o][k]; } : never)[] +>entriesOf : ({ [k in keyof o]-?: [k, o[k] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T ? { [k in keyof T]: T[k]; } : never)[] export const entriesOf = (o: o) => ->entriesOf : (o: o) => ({ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T extends unknown ? { [k in keyof T]: { [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o][k]; } : never)[] ->(o: o) => Object.entries(o) as entriesOf : (o: o) => ({ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T extends unknown ? { [k in keyof T]: { [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o][k]; } : never)[] +>entriesOf : (o: o) => ({ [k in keyof o]-?: [k, o[k] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T ? { [k in keyof T]: T[k]; } : never)[] +>(o: o) => Object.entries(o) as entriesOf : (o: o) => ({ [k in keyof o]-?: [k, o[k] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T ? { [k in keyof T]: T[k]; } : never)[] >o : o Object.entries(o) as entriesOf ->Object.entries(o) as entriesOf : ({ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T extends unknown ? { [k in keyof T]: { [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o][k]; } : never)[] +>Object.entries(o) as entriesOf : ({ [k in keyof o]-?: [k, o[k] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T ? { [k in keyof T]: T[k]; } : never)[] >Object.entries(o) : [string, any][] >Object.entries : { (o: ArrayLike | { [s: string]: T; }): [string, T][]; (o: {}): [string, any][]; } >Object : ObjectConstructor diff --git a/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypePreservesTypeParameterConstraint.types.diff b/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypePreservesTypeParameterConstraint.types.diff index 7e05817ad6..0bd36214a9 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypePreservesTypeParameterConstraint.types.diff +++ b/testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypePreservesTypeParameterConstraint.types.diff @@ -1,22 +1,13 @@ --- old.declarationEmitMappedTypePreservesTypeParameterConstraint.types +++ new.declarationEmitMappedTypePreservesTypeParameterConstraint.types -@@= skipped -45, +45 lines =@@ - }; - - export declare type objectOutputType = flatten< -->objectOutputType : addQuestionMarks, requiredKeys>> extends infer T ? { [k in keyof T]: T[k]; } : never -+>objectOutputType : addQuestionMarks, requiredKeys>> extends infer T extends unknown ? { [k in keyof T]: addQuestionMarks, requiredKeys>>[k]; } : never - - addQuestionMarks> - >; -@@= skipped -14, +14 lines =@@ +@@= skipped -59, +59 lines =@@ }; export const buildSchema = ( ->buildSchema : (version: V) => objectOutputType<{ version: ZodLiteral; }> ->( version: V): objectOutputType<{ version: ZodLiteral;}> => ({} as any) : (version: V) => objectOutputType<{ version: ZodLiteral; }> -+>buildSchema : (version: V) => addQuestionMarks; }>, undefined extends V ? never : "version"> extends infer T extends unknown ? { [k in keyof T]: addQuestionMarks; }>, undefined extends V ? never : "version">[k]; } : never -+>( version: V): objectOutputType<{ version: ZodLiteral;}> => ({} as any) : (version: V) => addQuestionMarks; }>, undefined extends V ? never : "version"> extends infer T extends unknown ? { [k in keyof T]: addQuestionMarks; }>, undefined extends V ? never : "version">[k]; } : never ++>buildSchema : (version: V) => addQuestionMarks; }>, undefined extends V ? never : "version"> extends infer T ? { [k in keyof T]: T[k]; } : never ++>( version: V): objectOutputType<{ version: ZodLiteral;}> => ({} as any) : (version: V) => addQuestionMarks; }>, undefined extends V ? never : "version"> extends infer T ? { [k in keyof T]: T[k]; } : never version: V >version : V @@ -25,7 +16,7 @@ export type entryOf = evaluate< ->entryOf : { [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T ? { [k in keyof T]: T[k]; } : never -+>entryOf : { [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T extends unknown ? { [k in keyof T]: { [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o][k]; } : never ++>entryOf : { [k in keyof o]-?: [k, o[k] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T ? { [k in keyof T]: T[k]; } : never { [k in keyof o]-?: [k, o[k] & ({} | null)] }[o extends readonly unknown[] ? keyof o & number @@ -34,18 +25,18 @@ export type entriesOf = evaluate[]> ->entriesOf : ({ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T ? { [k in keyof T]: T[k]; } : never)[] -+>entriesOf : ({ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T extends unknown ? { [k in keyof T]: { [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o][k]; } : never)[] ++>entriesOf : ({ [k in keyof o]-?: [k, o[k] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T ? { [k in keyof T]: T[k]; } : never)[] export const entriesOf = (o: o) => ->entriesOf : (o: o) => entriesOf ->(o: o) => Object.entries(o) as entriesOf : (o: o) => entriesOf -+>entriesOf : (o: o) => ({ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T extends unknown ? { [k in keyof T]: { [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o][k]; } : never)[] -+>(o: o) => Object.entries(o) as entriesOf : (o: o) => ({ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T extends unknown ? { [k in keyof T]: { [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o][k]; } : never)[] ++>entriesOf : (o: o) => ({ [k in keyof o]-?: [k, o[k] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T ? { [k in keyof T]: T[k]; } : never)[] ++>(o: o) => Object.entries(o) as entriesOf : (o: o) => ({ [k in keyof o]-?: [k, o[k] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T ? { [k in keyof T]: T[k]; } : never)[] >o : o Object.entries(o) as entriesOf ->Object.entries(o) as entriesOf : ({ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T ? { [k in keyof T]: T[k]; } : never)[] -+>Object.entries(o) as entriesOf : ({ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T extends unknown ? { [k in keyof T]: { [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o][k]; } : never)[] ++>Object.entries(o) as entriesOf : ({ [k in keyof o]-?: [k, o[k] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T ? { [k in keyof T]: T[k]; } : never)[] >Object.entries(o) : [string, any][] ->Object.entries : { (o: { [s: string]: T; } | ArrayLike): [string, T][]; (o: {}): [string, any][]; } +>Object.entries : { (o: ArrayLike | { [s: string]: T; }): [string, T][]; (o: {}): [string, any][]; } diff --git a/testdata/baselines/reference/submodule/compiler/declarationEmitPrivatePromiseLikeInterface.errors.txt b/testdata/baselines/reference/submodule/compiler/declarationEmitPrivatePromiseLikeInterface.errors.txt new file mode 100644 index 0000000000..31f88d2e8c --- /dev/null +++ b/testdata/baselines/reference/submodule/compiler/declarationEmitPrivatePromiseLikeInterface.errors.txt @@ -0,0 +1,42 @@ +Api.ts(6,5): error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed. +Api.ts(7,5): error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed. +Api.ts(8,5): error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed. + + +==== http-client.ts (0 errors) ==== + type TPromise = Omit, "then" | "catch"> & { + then( + onfulfilled?: ((value: ResolveType) => TResult1 | PromiseLike) | undefined | null, + onrejected?: ((reason: RejectType) => TResult2 | PromiseLike) | undefined | null, + ): TPromise; + catch( + onrejected?: ((reason: RejectType) => TResult | PromiseLike) | undefined | null, + ): TPromise; + }; + + export interface HttpResponse extends Response { + data: D; + error: E; + } + + export class HttpClient { + public request = (): TPromise> => { + return '' as any; + }; + } +==== Api.ts (3 errors) ==== + import { HttpClient } from "./http-client"; + + export class Api { + constructor(private http: HttpClient) { } + + abc1 = () => this.http.request(); + ~~~~ +!!! error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed. + abc2 = () => this.http.request(); + ~~~~ +!!! error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed. + abc3 = () => this.http.request(); + ~~~~ +!!! error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed. + } \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/declarationEmitPrivatePromiseLikeInterface.errors.txt.diff b/testdata/baselines/reference/submodule/compiler/declarationEmitPrivatePromiseLikeInterface.errors.txt.diff deleted file mode 100644 index 3659b93b5d..0000000000 --- a/testdata/baselines/reference/submodule/compiler/declarationEmitPrivatePromiseLikeInterface.errors.txt.diff +++ /dev/null @@ -1,46 +0,0 @@ ---- old.declarationEmitPrivatePromiseLikeInterface.errors.txt -+++ new.declarationEmitPrivatePromiseLikeInterface.errors.txt -@@= skipped -0, +0 lines =@@ --Api.ts(6,5): error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed. --Api.ts(7,5): error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed. --Api.ts(8,5): error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed. -- -- --==== http-client.ts (0 errors) ==== -- type TPromise = Omit, "then" | "catch"> & { -- then( -- onfulfilled?: ((value: ResolveType) => TResult1 | PromiseLike) | undefined | null, -- onrejected?: ((reason: RejectType) => TResult2 | PromiseLike) | undefined | null, -- ): TPromise; -- catch( -- onrejected?: ((reason: RejectType) => TResult | PromiseLike) | undefined | null, -- ): TPromise; -- }; -- -- export interface HttpResponse extends Response { -- data: D; -- error: E; -- } -- -- export class HttpClient { -- public request = (): TPromise> => { -- return '' as any; -- }; -- } --==== Api.ts (3 errors) ==== -- import { HttpClient } from "./http-client"; -- -- export class Api { -- constructor(private http: HttpClient) { } -- -- abc1 = () => this.http.request(); -- ~~~~ --!!! error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed. -- abc2 = () => this.http.request(); -- ~~~~ --!!! error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed. -- abc3 = () => this.http.request(); -- ~~~~ --!!! error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed. -- } -+ \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/declarationEmitPrivatePromiseLikeInterface.js b/testdata/baselines/reference/submodule/compiler/declarationEmitPrivatePromiseLikeInterface.js index e87fb9061c..20e1932a26 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationEmitPrivatePromiseLikeInterface.js +++ b/testdata/baselines/reference/submodule/compiler/declarationEmitPrivatePromiseLikeInterface.js @@ -78,383 +78,383 @@ export declare class Api { constructor(http: HttpClient); abc1: () => Omit>, "catch" | "then"> & { then, TResult2 = never>(onfulfilled?: (value: import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_9 | TResult2_9) => TResult1_10 | PromiseLike, onrejected?: (reason: any) => TResult2_10 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -462,381 +462,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -845,382 +845,382 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -1228,381 +1228,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -1613,382 +1613,382 @@ export declare class Api { }; }; catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + then(onfulfilled?: (value: TResult | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -1996,381 +1996,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -2379,382 +2379,382 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -2762,381 +2762,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -3149,382 +3149,382 @@ export declare class Api { }; catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { then, TResult2 = never>(onfulfilled?: (value: TResult | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -3532,381 +3532,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -3915,382 +3915,382 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -4298,381 +4298,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -4682,383 +4682,383 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit>, "catch" | "then"> & { then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -5066,381 +5066,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -5449,382 +5449,382 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit>, "catch" | "then"> & { then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -5832,386 +5832,180 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit>, "catch" | "then"> & { then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit & { + /*elided*/ }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { - then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { - then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { - then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { - then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { - then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { - then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult_9 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - }; - }; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit & { + /*elided*/ }; }; }; @@ -6220,383 +6014,383 @@ export declare class Api { }; abc2: () => Omit>, "catch" | "then"> & { then, TResult2 = never>(onfulfilled?: (value: import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_9 | TResult2_9) => TResult1_10 | PromiseLike, onrejected?: (reason: any) => TResult2_10 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -6604,381 +6398,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -6987,382 +6781,382 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -7370,381 +7164,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -7755,382 +7549,382 @@ export declare class Api { }; }; catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + then(onfulfilled?: (value: TResult | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -8138,381 +7932,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -8521,382 +8315,382 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -8904,381 +8698,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -9291,382 +9085,382 @@ export declare class Api { }; catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { then, TResult2 = never>(onfulfilled?: (value: TResult | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -9674,381 +9468,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -10057,382 +9851,382 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -10440,381 +10234,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -10824,383 +10618,383 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit>, "catch" | "then"> & { then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -11208,381 +11002,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -11591,382 +11385,382 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit>, "catch" | "then"> & { then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -11974,386 +11768,180 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit>, "catch" | "then"> & { then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit & { + /*elided*/ }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { - then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { - then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { - then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { - then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { - then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { - then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult_9 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - }; - }; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit & { + /*elided*/ }; }; }; @@ -12362,383 +11950,383 @@ export declare class Api { }; abc3: () => Omit>, "catch" | "then"> & { then, TResult2 = never>(onfulfilled?: (value: import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_9 | TResult2_9) => TResult1_10 | PromiseLike, onrejected?: (reason: any) => TResult2_10 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -12746,381 +12334,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -13129,382 +12717,382 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -13512,381 +13100,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -13897,382 +13485,382 @@ export declare class Api { }; }; catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + then(onfulfilled?: (value: TResult | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -14280,381 +13868,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -14663,382 +14251,382 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -15046,381 +14634,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -15433,382 +15021,382 @@ export declare class Api { }; catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { then, TResult2 = never>(onfulfilled?: (value: TResult | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -15816,381 +15404,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -16199,382 +15787,382 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -16582,381 +16170,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -16966,383 +16554,383 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { + catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit>, "catch" | "then"> & { then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -17350,381 +16938,381 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -17733,382 +17321,382 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { + catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit>, "catch" | "then"> & { then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; @@ -18116,386 +17704,180 @@ export declare class Api { }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { + catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit>, "catch" | "then"> & { then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { + then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit & /*elided*/ any; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; + catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit & { + /*elided*/ }; }; }; }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { - then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { - then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { - then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { - then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { - then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { - then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - }; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { - then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult_9 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; - catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & /*elided*/ any; - }; - }; - }; - }; - }; + catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit & { + /*elided*/ }; }; }; diff --git a/testdata/baselines/reference/submodule/compiler/declarationEmitPrivatePromiseLikeInterface.js.diff b/testdata/baselines/reference/submodule/compiler/declarationEmitPrivatePromiseLikeInterface.js.diff index c412074a8c..f7a0a40a93 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationEmitPrivatePromiseLikeInterface.js.diff +++ b/testdata/baselines/reference/submodule/compiler/declarationEmitPrivatePromiseLikeInterface.js.diff @@ -47,383 +47,383 @@ + constructor(http: HttpClient); + abc1: () => Omit>, "catch" | "then"> & { + then, TResult2 = never>(onfulfilled?: (value: import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_9 | TResult2_9) => TResult1_10 | PromiseLike, onrejected?: (reason: any) => TResult2_10 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -431,381 +431,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -814,382 +814,382 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -1197,381 +1197,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -1582,382 +1582,382 @@ + }; + }; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ then(onfulfilled?: (value: TResult | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -1965,381 +1965,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -2348,382 +2348,382 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -2731,381 +2731,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -3118,382 +3118,382 @@ + }; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { + then, TResult2 = never>(onfulfilled?: (value: TResult | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -3501,381 +3501,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -3884,382 +3884,382 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -4267,381 +4267,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -4651,383 +4651,383 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit>, "catch" | "then"> & { + then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -5035,381 +5035,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -5418,382 +5418,382 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit>, "catch" | "then"> & { + then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -5801,386 +5801,180 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit>, "catch" | "then"> & { + then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit & { ++ /*elided*/ + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { -+ then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { -+ then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { -+ then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { -+ then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { -+ then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { -+ then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult_9 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ }; -+ }; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit & { ++ /*elided*/ + }; + }; + }; @@ -6189,383 +5983,383 @@ + }; + abc2: () => Omit>, "catch" | "then"> & { + then, TResult2 = never>(onfulfilled?: (value: import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_9 | TResult2_9) => TResult1_10 | PromiseLike, onrejected?: (reason: any) => TResult2_10 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -6573,381 +6367,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -6956,382 +6750,382 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -7339,381 +7133,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -7724,382 +7518,382 @@ + }; + }; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ then(onfulfilled?: (value: TResult | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -8107,381 +7901,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -8490,382 +8284,382 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -8873,381 +8667,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -9260,382 +9054,382 @@ + }; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { + then, TResult2 = never>(onfulfilled?: (value: TResult | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -9643,381 +9437,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -10026,382 +9820,382 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -10409,381 +10203,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -10793,383 +10587,383 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit>, "catch" | "then"> & { + then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -11177,381 +10971,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -11560,382 +11354,382 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit>, "catch" | "then"> & { + then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -11943,386 +11737,180 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit>, "catch" | "then"> & { + then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit & { ++ /*elided*/ + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { -+ then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { -+ then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { -+ then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { -+ then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { -+ then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { -+ then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult_9 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ }; -+ }; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit & { ++ /*elided*/ + }; + }; + }; @@ -12331,383 +11919,383 @@ + }; + abc3: () => Omit>, "catch" | "then"> & { + then, TResult2 = never>(onfulfilled?: (value: import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_9 | TResult2_9) => TResult1_10 | PromiseLike, onrejected?: (reason: any) => TResult2_10 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -12715,381 +12303,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -13098,382 +12686,382 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -13481,381 +13069,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -13866,382 +13454,382 @@ + }; + }; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ then(onfulfilled?: (value: TResult | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -14249,381 +13837,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -14632,382 +14220,382 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -15015,381 +14603,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -15402,382 +14990,382 @@ + }; + catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { + then, TResult2 = never>(onfulfilled?: (value: TResult | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_8 | TResult2_8) => TResult1_9 | PromiseLike, onrejected?: (reason: any) => TResult2_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -15785,381 +15373,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -16168,382 +15756,382 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -16551,381 +16139,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -16935,383 +16523,383 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { ++ catch(onrejected?: (reason: any) => TResult_1 | PromiseLike): Omit>, "catch" | "then"> & { + then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_7 | TResult2_7) => TResult1_8 | PromiseLike, onrejected?: (reason: any) => TResult2_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -17319,381 +16907,381 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -17702,382 +17290,382 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { ++ catch(onrejected?: (reason: any) => TResult_2 | PromiseLike): Omit>, "catch" | "then"> & { + then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_6 | TResult2_6) => TResult1_7 | PromiseLike, onrejected?: (reason: any) => TResult2_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_9 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; @@ -18085,386 +17673,180 @@ + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { ++ catch(onrejected?: (reason: any) => TResult_3 | PromiseLike): Omit>, "catch" | "then"> & { + then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ then(onfulfilled?: (value: TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_5 | TResult2_5) => TResult1_6 | PromiseLike, onrejected?: (reason: any) => TResult2_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_4 | TResult2_4) => TResult1_5 | PromiseLike, onrejected?: (reason: any) => TResult2_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_5 | TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_5 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_4 | TResult_5 | TResult1 | TResult2) => TResult1_1 | PromiseLike, onrejected?: (reason: any) => TResult2_1 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_3 | TResult2_3) => TResult1_4 | PromiseLike, onrejected?: (reason: any) => TResult2_4 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult1_2 | TResult2_2) => TResult1_3 | PromiseLike, onrejected?: (reason: any) => TResult2_3 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_7 | PromiseLike): Omit, "catch" | "then"> & { ++ then(onfulfilled?: (value: TResult_6 | TResult_7 | TResult1_1 | TResult2_1) => TResult1_2 | PromiseLike, onrejected?: (reason: any) => TResult2_2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; ++ catch(onrejected?: (reason: any) => TResult_8 | PromiseLike): Omit & /*elided*/ any; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; ++ catch(onrejected?: (reason: any) => TResult_6 | PromiseLike): Omit & { ++ /*elided*/ + }; + }; + }; + }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { -+ then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { -+ then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { -+ then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult_1 | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { -+ then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult | TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { -+ then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & { -+ then(onfulfilled?: (value: TResult1_1 | TResult2_1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ }; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & { -+ then, TResult2 = never>(onfulfilled?: (value: TResult | TResult_1 | TResult_2 | TResult_3 | TResult_4 | TResult_5 | TResult_6 | TResult_7 | TResult_8 | TResult_9 | import("./http-client").HttpResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Omit, "catch" | "then"> & /*elided*/ any; -+ catch(onrejected?: (reason: any) => TResult | PromiseLike): Omit>, "catch" | "then"> & /*elided*/ any; -+ }; -+ }; -+ }; -+ }; -+ }; ++ catch(onrejected?: (reason: any) => TResult_4 | PromiseLike): Omit & { ++ /*elided*/ + }; + }; + }; diff --git a/testdata/baselines/reference/submodule/compiler/declarationEmitShadowingInferNotRenamed.js b/testdata/baselines/reference/submodule/compiler/declarationEmitShadowingInferNotRenamed.js index ee64eb9aee..93b903cc46 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationEmitShadowingInferNotRenamed.js +++ b/testdata/baselines/reference/submodule/compiler/declarationEmitShadowingInferNotRenamed.js @@ -37,5 +37,5 @@ exports.createClient = createClient; type UpdatedClient = C & { foo: number; }; -export declare const createClient: string> | (new (...args: any[]) => string)>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C ? UpdatedClient : never; }; +export declare const createClient: string> | (new (...args: any[]) => string)>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C_1 ? UpdatedClient : never; }; export {}; diff --git a/testdata/baselines/reference/submodule/compiler/declarationEmitShadowingInferNotRenamed.js.diff b/testdata/baselines/reference/submodule/compiler/declarationEmitShadowingInferNotRenamed.js.diff index ebb2e00aa2..897aca737b 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationEmitShadowingInferNotRenamed.js.diff +++ b/testdata/baselines/reference/submodule/compiler/declarationEmitShadowingInferNotRenamed.js.diff @@ -9,5 +9,5 @@ foo: number; }; -export declare const createClient: Client) | Record Client>>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C ? UpdatedClient : never; }; -+export declare const createClient: string> | (new (...args: any[]) => string)>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C ? UpdatedClient : never; }; ++export declare const createClient: string> | (new (...args: any[]) => string)>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C_1 ? UpdatedClient : never; }; export {}; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/declarationEmitShadowingInferNotRenamed.types b/testdata/baselines/reference/submodule/compiler/declarationEmitShadowingInferNotRenamed.types index 076b43b6f1..4184e99779 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationEmitShadowingInferNotRenamed.types +++ b/testdata/baselines/reference/submodule/compiler/declarationEmitShadowingInferNotRenamed.types @@ -11,8 +11,8 @@ type UpdatedClient = C & {foo: number} >foo : number export const createClient = < ->createClient : string> | (new (...args: any[]) => string)>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C ? UpdatedClient : never; } ->< D extends | (new (...args: any[]) => Client) // accept class | Record Client> // or map of classes>( clientDef: D): D extends new (...args: any[]) => infer C ? UpdatedClient // return instance : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C // or map of instances respectively ? UpdatedClient : never } => { return null as any} : string> | (new (...args: any[]) => string)>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C ? UpdatedClient : never; } +>createClient : string> | (new (...args: any[]) => string)>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C_1 ? UpdatedClient : never; } +>< D extends | (new (...args: any[]) => Client) // accept class | Record Client> // or map of classes>( clientDef: D): D extends new (...args: any[]) => infer C ? UpdatedClient // return instance : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C // or map of instances respectively ? UpdatedClient : never } => { return null as any} : string> | (new (...args: any[]) => string)>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C_1 ? UpdatedClient : never; } D extends | (new (...args: any[]) => Client) // accept class diff --git a/testdata/baselines/reference/submodule/compiler/declarationEmitShadowingInferNotRenamed.types.diff b/testdata/baselines/reference/submodule/compiler/declarationEmitShadowingInferNotRenamed.types.diff index e8f27daffd..ddba08eb7a 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationEmitShadowingInferNotRenamed.types.diff +++ b/testdata/baselines/reference/submodule/compiler/declarationEmitShadowingInferNotRenamed.types.diff @@ -6,8 +6,8 @@ export const createClient = < ->createClient : Client) | Record Client>>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C ? UpdatedClient : never; } ->< D extends | (new (...args: any[]) => Client) // accept class | Record Client> // or map of classes>( clientDef: D): D extends new (...args: any[]) => infer C ? UpdatedClient // return instance : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C // or map of instances respectively ? UpdatedClient : never } => { return null as any} : Client) | Record Client>>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C ? UpdatedClient : never; } -+>createClient : string> | (new (...args: any[]) => string)>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C ? UpdatedClient : never; } -+>< D extends | (new (...args: any[]) => Client) // accept class | Record Client> // or map of classes>( clientDef: D): D extends new (...args: any[]) => infer C ? UpdatedClient // return instance : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C // or map of instances respectively ? UpdatedClient : never } => { return null as any} : string> | (new (...args: any[]) => string)>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C ? UpdatedClient : never; } ++>createClient : string> | (new (...args: any[]) => string)>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C_1 ? UpdatedClient : never; } ++>< D extends | (new (...args: any[]) => Client) // accept class | Record Client> // or map of classes>( clientDef: D): D extends new (...args: any[]) => infer C ? UpdatedClient // return instance : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C // or map of instances respectively ? UpdatedClient : never } => { return null as any} : string> | (new (...args: any[]) => string)>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C_1 ? UpdatedClient : never; } D extends | (new (...args: any[]) => Client) // accept class \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.js b/testdata/baselines/reference/submodule/compiler/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.js index f9946ec7af..bf75d38e5a 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.js +++ b/testdata/baselines/reference/submodule/compiler/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.js @@ -89,36 +89,36 @@ void p3.result.three; //// [declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts] export type Key = keyof U; export type Value, U> = U[K]; -export declare const updateIfChanged: (t: T) => ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => /*elided*/ any & { - map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; - set: (newU: Value>>>>>>>>>>) => T; +export declare const updateIfChanged: (t: T) => ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => /*elided*/ any & { + map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; + set: (newU: Value>>>>>>>>>>) => T; }) & { - map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; - set: (newU: Value>>>>>>>>>) => T; + map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; + set: (newU: Value>>>>>>>>>) => T; }) & { - map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; - set: (newU: Value>>>>>>>>) => T; + map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; + set: (newU: Value>>>>>>>>) => T; }) & { - map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; - set: (newU: Value>>>>>>>) => T; + map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; + set: (newU: Value>>>>>>>) => T; }) & { - map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; - set: (newU: Value>>>>>>) => T; + map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; + set: (newU: Value>>>>>>) => T; }) & { - map: (updater: (u: Value>>>>>) => Value>>>>>) => T; - set: (newU: Value>>>>>) => T; + map: (updater: (u: Value>>>>>) => Value>>>>>) => T; + set: (newU: Value>>>>>) => T; }) & { - map: (updater: (u: Value>>>>) => Value>>>>) => T; - set: (newU: Value>>>>) => T; + map: (updater: (u: Value>>>>) => Value>>>>) => T; + set: (newU: Value>>>>) => T; }) & { - map: (updater: (u: Value>>>) => Value>>>) => T; - set: (newU: Value>>>) => T; + map: (updater: (u: Value>>>) => Value>>>) => T; + set: (newU: Value>>>) => T; }) & { - map: (updater: (u: Value>>) => Value>>) => T; - set: (newU: Value>>) => T; + map: (updater: (u: Value>>) => Value>>) => T; + set: (newU: Value>>) => T; }) & { - map: (updater: (u: Value>) => Value>) => T; - set: (newU: Value>) => T; + map: (updater: (u: Value>) => Value>) => T; + set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; @@ -130,25 +130,25 @@ export declare const testRecFun: (parent: T) => { result: T; deeper: (child: U) => { result: T & U; - deeper: (child: U) => { - result: T & U_1 & U; - deeper: (child: U) => { - result: T & U_1 & U_2 & U; - deeper: (child: U) => { - result: T & U_1 & U_2 & U_3 & U; - deeper: (child: U) => { - result: T & U_1 & U_2 & U_3 & U_4 & U; - deeper: (child: U) => { - result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; - deeper: (child: U) => { - result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; - deeper: (child: U) => { - result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; - deeper: (child: U) => { - result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; - deeper: (child: U) => { - result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; - deeper: (child: U) => /*elided*/ any; + deeper: (child: U_1) => { + result: T & U & U_1; + deeper: (child: U_2) => { + result: T & U & U_1 & U_2; + deeper: (child: U_3) => { + result: T & U & U_1 & U_2 & U_3; + deeper: (child: U_4) => { + result: T & U & U_1 & U_2 & U_3 & U_4; + deeper: (child: U_5) => { + result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; + deeper: (child: U_6) => { + result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; + deeper: (child: U_7) => { + result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; + deeper: (child: U_8) => { + result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; + deeper: (child: U_9) => { + result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; + deeper: (child: U_10) => /*elided*/ any; }; }; }; @@ -160,880 +160,3 @@ export declare const testRecFun: (parent: T) => { }; }; }; - - -//// [DtsFileErrors] - - -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,108): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,152): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,163): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,208): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,219): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,230): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,276): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,287): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,298): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,309): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,356): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,367): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,378): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,389): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,400): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,448): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,459): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,470): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,481): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,492): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,503): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,552): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,563): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,574): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,585): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,596): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,607): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,618): error TS2304: Cannot find name 'K_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,668): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,679): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,690): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,701): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,712): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,723): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,734): error TS2304: Cannot find name 'K_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,745): error TS2304: Cannot find name 'K_8'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,796): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,807): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,818): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,829): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,840): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,851): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,862): error TS2304: Cannot find name 'K_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,873): error TS2304: Cannot find name 'K_8'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,884): error TS2304: Cannot find name 'K_9'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,936): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,947): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,958): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,969): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,980): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,991): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,1002): error TS2304: Cannot find name 'K_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,1013): error TS2304: Cannot find name 'K_8'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,1024): error TS2304: Cannot find name 'K_9'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,1035): error TS2304: Cannot find name 'K_10'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,39): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,50): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,61): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,72): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,83): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,94): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,105): error TS2304: Cannot find name 'K_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,116): error TS2304: Cannot find name 'K_8'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,127): error TS2304: Cannot find name 'K_9'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,138): error TS2304: Cannot find name 'K_10'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,176): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,187): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,198): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,209): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,220): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,231): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,242): error TS2304: Cannot find name 'K_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,253): error TS2304: Cannot find name 'K_8'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,264): error TS2304: Cannot find name 'K_9'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,275): error TS2304: Cannot find name 'K_10'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,32): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,43): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,54): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,65): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,76): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,87): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,98): error TS2304: Cannot find name 'K_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,109): error TS2304: Cannot find name 'K_8'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,120): error TS2304: Cannot find name 'K_9'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,131): error TS2304: Cannot find name 'K_10'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,39): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,50): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,61): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,72): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,83): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,94): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,105): error TS2304: Cannot find name 'K_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,116): error TS2304: Cannot find name 'K_8'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,127): error TS2304: Cannot find name 'K_9'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,163): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,174): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,185): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,196): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,207): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,218): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,229): error TS2304: Cannot find name 'K_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,240): error TS2304: Cannot find name 'K_8'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,251): error TS2304: Cannot find name 'K_9'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(8,32): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(8,43): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(8,54): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(8,65): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(8,76): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(8,87): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(8,98): error TS2304: Cannot find name 'K_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(8,109): error TS2304: Cannot find name 'K_8'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(8,120): error TS2304: Cannot find name 'K_9'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,39): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,50): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,61): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,72): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,83): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,94): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,105): error TS2304: Cannot find name 'K_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,116): error TS2304: Cannot find name 'K_8'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,151): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,162): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,173): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,184): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,195): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,206): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,217): error TS2304: Cannot find name 'K_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,228): error TS2304: Cannot find name 'K_8'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(11,32): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(11,43): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(11,54): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(11,65): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(11,76): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(11,87): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(11,98): error TS2304: Cannot find name 'K_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(11,109): error TS2304: Cannot find name 'K_8'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,39): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,50): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,61): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,72): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,83): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,94): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,105): error TS2304: Cannot find name 'K_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,139): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,150): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,161): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,172): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,183): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,194): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,205): error TS2304: Cannot find name 'K_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(14,32): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(14,43): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(14,54): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(14,65): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(14,76): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(14,87): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(14,98): error TS2304: Cannot find name 'K_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,39): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,50): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,61): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,72): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,83): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,94): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,127): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,138): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,149): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,160): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,171): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,182): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(17,32): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(17,43): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(17,54): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(17,65): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(17,76): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(17,87): error TS2304: Cannot find name 'K_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,39): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,50): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,61): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,72): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,83): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,115): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,126): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,137): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,148): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,159): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(20,32): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(20,43): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(20,54): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(20,65): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(20,76): error TS2304: Cannot find name 'K_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(22,39): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(22,50): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(22,61): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(22,72): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(22,103): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(22,114): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(22,125): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(22,136): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(23,32): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(23,43): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(23,54): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(23,65): error TS2304: Cannot find name 'K_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(25,39): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(25,50): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(25,61): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(25,91): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(25,102): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(25,113): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(26,32): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(26,43): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(26,54): error TS2304: Cannot find name 'K_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(28,39): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(28,50): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(28,79): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(28,90): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(29,32): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(29,43): error TS2304: Cannot find name 'K_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(31,39): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(31,67): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(32,32): error TS2304: Cannot find name 'K_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(45,25): error TS2304: Cannot find name 'U_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(47,29): error TS2304: Cannot find name 'U_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(47,35): error TS2304: Cannot find name 'U_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(49,33): error TS2304: Cannot find name 'U_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(49,39): error TS2304: Cannot find name 'U_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(49,45): error TS2304: Cannot find name 'U_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(51,37): error TS2304: Cannot find name 'U_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(51,43): error TS2304: Cannot find name 'U_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(51,49): error TS2304: Cannot find name 'U_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(51,55): error TS2304: Cannot find name 'U_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(53,41): error TS2304: Cannot find name 'U_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(53,47): error TS2304: Cannot find name 'U_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(53,53): error TS2304: Cannot find name 'U_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(53,59): error TS2304: Cannot find name 'U_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(53,65): error TS2304: Cannot find name 'U_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(55,45): error TS2304: Cannot find name 'U_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(55,51): error TS2304: Cannot find name 'U_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(55,57): error TS2304: Cannot find name 'U_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(55,63): error TS2304: Cannot find name 'U_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(55,69): error TS2304: Cannot find name 'U_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(55,75): error TS2304: Cannot find name 'U_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(57,49): error TS2304: Cannot find name 'U_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(57,55): error TS2304: Cannot find name 'U_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(57,61): error TS2304: Cannot find name 'U_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(57,67): error TS2304: Cannot find name 'U_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(57,73): error TS2304: Cannot find name 'U_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(57,79): error TS2304: Cannot find name 'U_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(57,85): error TS2304: Cannot find name 'U_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(59,53): error TS2304: Cannot find name 'U_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(59,59): error TS2304: Cannot find name 'U_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(59,65): error TS2304: Cannot find name 'U_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(59,71): error TS2304: Cannot find name 'U_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(59,77): error TS2304: Cannot find name 'U_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(59,83): error TS2304: Cannot find name 'U_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(59,89): error TS2304: Cannot find name 'U_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(59,95): error TS2304: Cannot find name 'U_8'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(61,57): error TS2304: Cannot find name 'U_1'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(61,63): error TS2304: Cannot find name 'U_2'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(61,69): error TS2304: Cannot find name 'U_3'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(61,75): error TS2304: Cannot find name 'U_4'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(61,81): error TS2304: Cannot find name 'U_5'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(61,87): error TS2304: Cannot find name 'U_6'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(61,93): error TS2304: Cannot find name 'U_7'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(61,99): error TS2304: Cannot find name 'U_8'. -declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(61,105): error TS2304: Cannot find name 'U_9'. - - -==== declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts (265 errors) ==== - export type Key = keyof U; - export type Value, U> = U[K]; - export declare const updateIfChanged: (t: T) => ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => /*elided*/ any & { - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - ~~~ -!!! error TS2304: Cannot find name 'K_7'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - ~~~ -!!! error TS2304: Cannot find name 'K_7'. - ~~~ -!!! error TS2304: Cannot find name 'K_8'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - ~~~ -!!! error TS2304: Cannot find name 'K_7'. - ~~~ -!!! error TS2304: Cannot find name 'K_8'. - ~~~ -!!! error TS2304: Cannot find name 'K_9'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - ~~~ -!!! error TS2304: Cannot find name 'K_7'. - ~~~ -!!! error TS2304: Cannot find name 'K_8'. - ~~~ -!!! error TS2304: Cannot find name 'K_9'. - ~~~~ -!!! error TS2304: Cannot find name 'K_10'. - map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - ~~~ -!!! error TS2304: Cannot find name 'K_7'. - ~~~ -!!! error TS2304: Cannot find name 'K_8'. - ~~~ -!!! error TS2304: Cannot find name 'K_9'. - ~~~~ -!!! error TS2304: Cannot find name 'K_10'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - ~~~ -!!! error TS2304: Cannot find name 'K_7'. - ~~~ -!!! error TS2304: Cannot find name 'K_8'. - ~~~ -!!! error TS2304: Cannot find name 'K_9'. - ~~~~ -!!! error TS2304: Cannot find name 'K_10'. - set: (newU: Value>>>>>>>>>>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - ~~~ -!!! error TS2304: Cannot find name 'K_7'. - ~~~ -!!! error TS2304: Cannot find name 'K_8'. - ~~~ -!!! error TS2304: Cannot find name 'K_9'. - ~~~~ -!!! error TS2304: Cannot find name 'K_10'. - }) & { - map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - ~~~ -!!! error TS2304: Cannot find name 'K_7'. - ~~~ -!!! error TS2304: Cannot find name 'K_8'. - ~~~ -!!! error TS2304: Cannot find name 'K_9'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - ~~~ -!!! error TS2304: Cannot find name 'K_7'. - ~~~ -!!! error TS2304: Cannot find name 'K_8'. - ~~~ -!!! error TS2304: Cannot find name 'K_9'. - set: (newU: Value>>>>>>>>>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - ~~~ -!!! error TS2304: Cannot find name 'K_7'. - ~~~ -!!! error TS2304: Cannot find name 'K_8'. - ~~~ -!!! error TS2304: Cannot find name 'K_9'. - }) & { - map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - ~~~ -!!! error TS2304: Cannot find name 'K_7'. - ~~~ -!!! error TS2304: Cannot find name 'K_8'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - ~~~ -!!! error TS2304: Cannot find name 'K_7'. - ~~~ -!!! error TS2304: Cannot find name 'K_8'. - set: (newU: Value>>>>>>>>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - ~~~ -!!! error TS2304: Cannot find name 'K_7'. - ~~~ -!!! error TS2304: Cannot find name 'K_8'. - }) & { - map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - ~~~ -!!! error TS2304: Cannot find name 'K_7'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - ~~~ -!!! error TS2304: Cannot find name 'K_7'. - set: (newU: Value>>>>>>>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - ~~~ -!!! error TS2304: Cannot find name 'K_7'. - }) & { - map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - set: (newU: Value>>>>>>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_6'. - }) & { - map: (updater: (u: Value>>>>>) => Value>>>>>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - set: (newU: Value>>>>>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_5'. - }) & { - map: (updater: (u: Value>>>>) => Value>>>>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - set: (newU: Value>>>>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_4'. - }) & { - map: (updater: (u: Value>>>) => Value>>>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - set: (newU: Value>>>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_3'. - }) & { - map: (updater: (u: Value>>) => Value>>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - set: (newU: Value>>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_2'. - }) & { - map: (updater: (u: Value>) => Value>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - set: (newU: Value>) => T; - ~~~ -!!! error TS2304: Cannot find name 'K_1'. - }) & { - map: (updater: (u: Value) => Value) => T; - set: (newU: Value) => T; - }) & { - map: (updater: (u: T) => T) => T; - set: (newU: T) => T; - }; - export declare const testRecFun: (parent: T) => { - result: T; - deeper: (child: U) => { - result: T & U; - deeper: (child: U) => { - result: T & U_1 & U; - ~~~ -!!! error TS2304: Cannot find name 'U_1'. - deeper: (child: U) => { - result: T & U_1 & U_2 & U; - ~~~ -!!! error TS2304: Cannot find name 'U_1'. - ~~~ -!!! error TS2304: Cannot find name 'U_2'. - deeper: (child: U) => { - result: T & U_1 & U_2 & U_3 & U; - ~~~ -!!! error TS2304: Cannot find name 'U_1'. - ~~~ -!!! error TS2304: Cannot find name 'U_2'. - ~~~ -!!! error TS2304: Cannot find name 'U_3'. - deeper: (child: U) => { - result: T & U_1 & U_2 & U_3 & U_4 & U; - ~~~ -!!! error TS2304: Cannot find name 'U_1'. - ~~~ -!!! error TS2304: Cannot find name 'U_2'. - ~~~ -!!! error TS2304: Cannot find name 'U_3'. - ~~~ -!!! error TS2304: Cannot find name 'U_4'. - deeper: (child: U) => { - result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; - ~~~ -!!! error TS2304: Cannot find name 'U_1'. - ~~~ -!!! error TS2304: Cannot find name 'U_2'. - ~~~ -!!! error TS2304: Cannot find name 'U_3'. - ~~~ -!!! error TS2304: Cannot find name 'U_4'. - ~~~ -!!! error TS2304: Cannot find name 'U_5'. - deeper: (child: U) => { - result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; - ~~~ -!!! error TS2304: Cannot find name 'U_1'. - ~~~ -!!! error TS2304: Cannot find name 'U_2'. - ~~~ -!!! error TS2304: Cannot find name 'U_3'. - ~~~ -!!! error TS2304: Cannot find name 'U_4'. - ~~~ -!!! error TS2304: Cannot find name 'U_5'. - ~~~ -!!! error TS2304: Cannot find name 'U_6'. - deeper: (child: U) => { - result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; - ~~~ -!!! error TS2304: Cannot find name 'U_1'. - ~~~ -!!! error TS2304: Cannot find name 'U_2'. - ~~~ -!!! error TS2304: Cannot find name 'U_3'. - ~~~ -!!! error TS2304: Cannot find name 'U_4'. - ~~~ -!!! error TS2304: Cannot find name 'U_5'. - ~~~ -!!! error TS2304: Cannot find name 'U_6'. - ~~~ -!!! error TS2304: Cannot find name 'U_7'. - deeper: (child: U) => { - result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; - ~~~ -!!! error TS2304: Cannot find name 'U_1'. - ~~~ -!!! error TS2304: Cannot find name 'U_2'. - ~~~ -!!! error TS2304: Cannot find name 'U_3'. - ~~~ -!!! error TS2304: Cannot find name 'U_4'. - ~~~ -!!! error TS2304: Cannot find name 'U_5'. - ~~~ -!!! error TS2304: Cannot find name 'U_6'. - ~~~ -!!! error TS2304: Cannot find name 'U_7'. - ~~~ -!!! error TS2304: Cannot find name 'U_8'. - deeper: (child: U) => { - result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; - ~~~ -!!! error TS2304: Cannot find name 'U_1'. - ~~~ -!!! error TS2304: Cannot find name 'U_2'. - ~~~ -!!! error TS2304: Cannot find name 'U_3'. - ~~~ -!!! error TS2304: Cannot find name 'U_4'. - ~~~ -!!! error TS2304: Cannot find name 'U_5'. - ~~~ -!!! error TS2304: Cannot find name 'U_6'. - ~~~ -!!! error TS2304: Cannot find name 'U_7'. - ~~~ -!!! error TS2304: Cannot find name 'U_8'. - ~~~ -!!! error TS2304: Cannot find name 'U_9'. - deeper: (child: U) => /*elided*/ any; - }; - }; - }; - }; - }; - }; - }; - }; - }; - }; - }; - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.js.diff b/testdata/baselines/reference/submodule/compiler/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.js.diff index 395d957158..936f834eeb 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.js.diff +++ b/testdata/baselines/reference/submodule/compiler/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.js.diff @@ -8,997 +8,4 @@ -// for having too many instances of the same symbol nesting. var __assign = (this && this.__assign) || function () { __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { -@@= skipped -47, +45 lines =@@ - //// [declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts] - export type Key = keyof U; - export type Value, U> = U[K]; --export declare const updateIfChanged: (t: T) => ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => /*elided*/ any & { -- map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; -- set: (newU: Value>>>>>>>>>>) => T; --}) & { -- map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; -- set: (newU: Value>>>>>>>>>) => T; --}) & { -- map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; -- set: (newU: Value>>>>>>>>) => T; --}) & { -- map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; -- set: (newU: Value>>>>>>>) => T; --}) & { -- map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; -- set: (newU: Value>>>>>>) => T; --}) & { -- map: (updater: (u: Value>>>>>) => Value>>>>>) => T; -- set: (newU: Value>>>>>) => T; --}) & { -- map: (updater: (u: Value>>>>) => Value>>>>) => T; -- set: (newU: Value>>>>) => T; --}) & { -- map: (updater: (u: Value>>>) => Value>>>) => T; -- set: (newU: Value>>>) => T; --}) & { -- map: (updater: (u: Value>>) => Value>>) => T; -- set: (newU: Value>>) => T; --}) & { -- map: (updater: (u: Value>) => Value>) => T; -- set: (newU: Value>) => T; -+export declare const updateIfChanged: (t: T) => ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => /*elided*/ any & { -+ map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; -+ set: (newU: Value>>>>>>>>>>) => T; -+}) & { -+ map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; -+ set: (newU: Value>>>>>>>>>) => T; -+}) & { -+ map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; -+ set: (newU: Value>>>>>>>>) => T; -+}) & { -+ map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; -+ set: (newU: Value>>>>>>>) => T; -+}) & { -+ map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; -+ set: (newU: Value>>>>>>) => T; -+}) & { -+ map: (updater: (u: Value>>>>>) => Value>>>>>) => T; -+ set: (newU: Value>>>>>) => T; -+}) & { -+ map: (updater: (u: Value>>>>) => Value>>>>) => T; -+ set: (newU: Value>>>>) => T; -+}) & { -+ map: (updater: (u: Value>>>) => Value>>>) => T; -+ set: (newU: Value>>>) => T; -+}) & { -+ map: (updater: (u: Value>>) => Value>>) => T; -+ set: (newU: Value>>) => T; -+}) & { -+ map: (updater: (u: Value>) => Value>) => T; -+ set: (newU: Value>) => T; - }) & { - map: (updater: (u: Value) => Value) => T; - set: (newU: Value) => T; -@@= skipped -41, +41 lines =@@ - result: T; - deeper: (child: U) => { - result: T & U; -- deeper: (child: U_1) => { -- result: T & U & U_1; -- deeper: (child: U_2) => { -- result: T & U & U_1 & U_2; -- deeper: (child: U_3) => { -- result: T & U & U_1 & U_2 & U_3; -- deeper: (child: U_4) => { -- result: T & U & U_1 & U_2 & U_3 & U_4; -- deeper: (child: U_5) => { -- result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; -- deeper: (child: U_6) => { -- result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; -- deeper: (child: U_7) => { -- result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; -- deeper: (child: U_8) => { -- result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; -- deeper: (child: U_9) => { -- result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; -- deeper: (child: U_10) => /*elided*/ any; -+ deeper: (child: U) => { -+ result: T & U_1 & U; -+ deeper: (child: U) => { -+ result: T & U_1 & U_2 & U; -+ deeper: (child: U) => { -+ result: T & U_1 & U_2 & U_3 & U; -+ deeper: (child: U) => { -+ result: T & U_1 & U_2 & U_3 & U_4 & U; -+ deeper: (child: U) => { -+ result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; -+ deeper: (child: U) => { -+ result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; -+ deeper: (child: U) => { -+ result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; -+ deeper: (child: U) => { -+ result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; -+ deeper: (child: U) => { -+ result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; -+ deeper: (child: U) => /*elided*/ any; - }; - }; - }; -@@= skipped -30, +30 lines =@@ - }; - }; - }; -+ -+ -+//// [DtsFileErrors] -+ -+ -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,108): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,152): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,163): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,208): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,219): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,230): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,276): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,287): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,298): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,309): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,356): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,367): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,378): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,389): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,400): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,448): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,459): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,470): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,481): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,492): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,503): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,552): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,563): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,574): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,585): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,596): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,607): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,618): error TS2304: Cannot find name 'K_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,668): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,679): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,690): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,701): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,712): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,723): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,734): error TS2304: Cannot find name 'K_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,745): error TS2304: Cannot find name 'K_8'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,796): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,807): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,818): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,829): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,840): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,851): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,862): error TS2304: Cannot find name 'K_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,873): error TS2304: Cannot find name 'K_8'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,884): error TS2304: Cannot find name 'K_9'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,936): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,947): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,958): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,969): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,980): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,991): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,1002): error TS2304: Cannot find name 'K_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,1013): error TS2304: Cannot find name 'K_8'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,1024): error TS2304: Cannot find name 'K_9'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(3,1035): error TS2304: Cannot find name 'K_10'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,39): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,50): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,61): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,72): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,83): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,94): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,105): error TS2304: Cannot find name 'K_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,116): error TS2304: Cannot find name 'K_8'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,127): error TS2304: Cannot find name 'K_9'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,138): error TS2304: Cannot find name 'K_10'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,176): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,187): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,198): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,209): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,220): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,231): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,242): error TS2304: Cannot find name 'K_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,253): error TS2304: Cannot find name 'K_8'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,264): error TS2304: Cannot find name 'K_9'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(4,275): error TS2304: Cannot find name 'K_10'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,32): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,43): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,54): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,65): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,76): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,87): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,98): error TS2304: Cannot find name 'K_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,109): error TS2304: Cannot find name 'K_8'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,120): error TS2304: Cannot find name 'K_9'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(5,131): error TS2304: Cannot find name 'K_10'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,39): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,50): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,61): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,72): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,83): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,94): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,105): error TS2304: Cannot find name 'K_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,116): error TS2304: Cannot find name 'K_8'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,127): error TS2304: Cannot find name 'K_9'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,163): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,174): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,185): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,196): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,207): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,218): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,229): error TS2304: Cannot find name 'K_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,240): error TS2304: Cannot find name 'K_8'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(7,251): error TS2304: Cannot find name 'K_9'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(8,32): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(8,43): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(8,54): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(8,65): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(8,76): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(8,87): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(8,98): error TS2304: Cannot find name 'K_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(8,109): error TS2304: Cannot find name 'K_8'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(8,120): error TS2304: Cannot find name 'K_9'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,39): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,50): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,61): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,72): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,83): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,94): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,105): error TS2304: Cannot find name 'K_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,116): error TS2304: Cannot find name 'K_8'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,151): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,162): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,173): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,184): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,195): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,206): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,217): error TS2304: Cannot find name 'K_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(10,228): error TS2304: Cannot find name 'K_8'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(11,32): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(11,43): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(11,54): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(11,65): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(11,76): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(11,87): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(11,98): error TS2304: Cannot find name 'K_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(11,109): error TS2304: Cannot find name 'K_8'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,39): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,50): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,61): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,72): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,83): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,94): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,105): error TS2304: Cannot find name 'K_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,139): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,150): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,161): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,172): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,183): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,194): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(13,205): error TS2304: Cannot find name 'K_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(14,32): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(14,43): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(14,54): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(14,65): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(14,76): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(14,87): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(14,98): error TS2304: Cannot find name 'K_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,39): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,50): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,61): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,72): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,83): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,94): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,127): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,138): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,149): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,160): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,171): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(16,182): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(17,32): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(17,43): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(17,54): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(17,65): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(17,76): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(17,87): error TS2304: Cannot find name 'K_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,39): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,50): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,61): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,72): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,83): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,115): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,126): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,137): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,148): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(19,159): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(20,32): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(20,43): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(20,54): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(20,65): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(20,76): error TS2304: Cannot find name 'K_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(22,39): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(22,50): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(22,61): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(22,72): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(22,103): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(22,114): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(22,125): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(22,136): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(23,32): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(23,43): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(23,54): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(23,65): error TS2304: Cannot find name 'K_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(25,39): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(25,50): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(25,61): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(25,91): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(25,102): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(25,113): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(26,32): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(26,43): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(26,54): error TS2304: Cannot find name 'K_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(28,39): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(28,50): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(28,79): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(28,90): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(29,32): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(29,43): error TS2304: Cannot find name 'K_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(31,39): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(31,67): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(32,32): error TS2304: Cannot find name 'K_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(45,25): error TS2304: Cannot find name 'U_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(47,29): error TS2304: Cannot find name 'U_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(47,35): error TS2304: Cannot find name 'U_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(49,33): error TS2304: Cannot find name 'U_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(49,39): error TS2304: Cannot find name 'U_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(49,45): error TS2304: Cannot find name 'U_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(51,37): error TS2304: Cannot find name 'U_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(51,43): error TS2304: Cannot find name 'U_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(51,49): error TS2304: Cannot find name 'U_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(51,55): error TS2304: Cannot find name 'U_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(53,41): error TS2304: Cannot find name 'U_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(53,47): error TS2304: Cannot find name 'U_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(53,53): error TS2304: Cannot find name 'U_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(53,59): error TS2304: Cannot find name 'U_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(53,65): error TS2304: Cannot find name 'U_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(55,45): error TS2304: Cannot find name 'U_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(55,51): error TS2304: Cannot find name 'U_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(55,57): error TS2304: Cannot find name 'U_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(55,63): error TS2304: Cannot find name 'U_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(55,69): error TS2304: Cannot find name 'U_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(55,75): error TS2304: Cannot find name 'U_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(57,49): error TS2304: Cannot find name 'U_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(57,55): error TS2304: Cannot find name 'U_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(57,61): error TS2304: Cannot find name 'U_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(57,67): error TS2304: Cannot find name 'U_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(57,73): error TS2304: Cannot find name 'U_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(57,79): error TS2304: Cannot find name 'U_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(57,85): error TS2304: Cannot find name 'U_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(59,53): error TS2304: Cannot find name 'U_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(59,59): error TS2304: Cannot find name 'U_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(59,65): error TS2304: Cannot find name 'U_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(59,71): error TS2304: Cannot find name 'U_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(59,77): error TS2304: Cannot find name 'U_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(59,83): error TS2304: Cannot find name 'U_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(59,89): error TS2304: Cannot find name 'U_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(59,95): error TS2304: Cannot find name 'U_8'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(61,57): error TS2304: Cannot find name 'U_1'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(61,63): error TS2304: Cannot find name 'U_2'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(61,69): error TS2304: Cannot find name 'U_3'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(61,75): error TS2304: Cannot find name 'U_4'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(61,81): error TS2304: Cannot find name 'U_5'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(61,87): error TS2304: Cannot find name 'U_6'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(61,93): error TS2304: Cannot find name 'U_7'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(61,99): error TS2304: Cannot find name 'U_8'. -+declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts(61,105): error TS2304: Cannot find name 'U_9'. -+ -+ -+==== declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.d.ts (265 errors) ==== -+ export type Key = keyof U; -+ export type Value, U> = U[K]; -+ export declare const updateIfChanged: (t: T) => ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => /*elided*/ any & { -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_7'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_7'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_8'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_7'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_8'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_9'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_7'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_8'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_9'. -+ ~~~~ -+!!! error TS2304: Cannot find name 'K_10'. -+ map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_7'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_8'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_9'. -+ ~~~~ -+!!! error TS2304: Cannot find name 'K_10'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_7'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_8'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_9'. -+ ~~~~ -+!!! error TS2304: Cannot find name 'K_10'. -+ set: (newU: Value>>>>>>>>>>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_7'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_8'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_9'. -+ ~~~~ -+!!! error TS2304: Cannot find name 'K_10'. -+ }) & { -+ map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_7'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_8'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_9'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_7'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_8'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_9'. -+ set: (newU: Value>>>>>>>>>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_7'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_8'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_9'. -+ }) & { -+ map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_7'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_8'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_7'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_8'. -+ set: (newU: Value>>>>>>>>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_7'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_8'. -+ }) & { -+ map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_7'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_7'. -+ set: (newU: Value>>>>>>>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_7'. -+ }) & { -+ map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ set: (newU: Value>>>>>>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_6'. -+ }) & { -+ map: (updater: (u: Value>>>>>) => Value>>>>>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ set: (newU: Value>>>>>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_5'. -+ }) & { -+ map: (updater: (u: Value>>>>) => Value>>>>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ set: (newU: Value>>>>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_4'. -+ }) & { -+ map: (updater: (u: Value>>>) => Value>>>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ set: (newU: Value>>>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_3'. -+ }) & { -+ map: (updater: (u: Value>>) => Value>>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ set: (newU: Value>>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_2'. -+ }) & { -+ map: (updater: (u: Value>) => Value>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ set: (newU: Value>) => T; -+ ~~~ -+!!! error TS2304: Cannot find name 'K_1'. -+ }) & { -+ map: (updater: (u: Value) => Value) => T; -+ set: (newU: Value) => T; -+ }) & { -+ map: (updater: (u: T) => T) => T; -+ set: (newU: T) => T; -+ }; -+ export declare const testRecFun: (parent: T) => { -+ result: T; -+ deeper: (child: U) => { -+ result: T & U; -+ deeper: (child: U) => { -+ result: T & U_1 & U; -+ ~~~ -+!!! error TS2304: Cannot find name 'U_1'. -+ deeper: (child: U) => { -+ result: T & U_1 & U_2 & U; -+ ~~~ -+!!! error TS2304: Cannot find name 'U_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_2'. -+ deeper: (child: U) => { -+ result: T & U_1 & U_2 & U_3 & U; -+ ~~~ -+!!! error TS2304: Cannot find name 'U_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_3'. -+ deeper: (child: U) => { -+ result: T & U_1 & U_2 & U_3 & U_4 & U; -+ ~~~ -+!!! error TS2304: Cannot find name 'U_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_4'. -+ deeper: (child: U) => { -+ result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; -+ ~~~ -+!!! error TS2304: Cannot find name 'U_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_5'. -+ deeper: (child: U) => { -+ result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; -+ ~~~ -+!!! error TS2304: Cannot find name 'U_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_6'. -+ deeper: (child: U) => { -+ result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; -+ ~~~ -+!!! error TS2304: Cannot find name 'U_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_7'. -+ deeper: (child: U) => { -+ result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; -+ ~~~ -+!!! error TS2304: Cannot find name 'U_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_7'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_8'. -+ deeper: (child: U) => { -+ result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; -+ ~~~ -+!!! error TS2304: Cannot find name 'U_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_2'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_3'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_4'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_5'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_6'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_7'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_8'. -+ ~~~ -+!!! error TS2304: Cannot find name 'U_9'. -+ deeper: (child: U) => /*elided*/ any; -+ }; -+ }; -+ }; -+ }; -+ }; -+ }; -+ }; -+ }; -+ }; -+ }; -+ }; -+ \ No newline at end of file + for (var s, i = 1, n = arguments.length; i < n; i++) { \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.types b/testdata/baselines/reference/submodule/compiler/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.types index abe13a1200..b6fe43222c 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.types +++ b/testdata/baselines/reference/submodule/compiler/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.types @@ -12,13 +12,13 @@ export type Value, U> = U[K]; >Value : Value export const updateIfChanged = (t: T) => { ->updateIfChanged : (t: T) => ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: T) => T) => T; set: (newU: T) => T; } ->(t: T) => { const reduce = (u: U, update: (u: U) => T) => { const set = (newU: U) => Object.is(u, newU) ? t : update(newU); return Object.assign( >(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }), { map: (updater: (u: U) => U) => set(updater(u)), set }); }; return reduce(t, (t: T) => t);} : (t: T) => ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: T) => T) => T; set: (newU: T) => T; } +>updateIfChanged : (t: T) => ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: T) => T) => T; set: (newU: T) => T; } +>(t: T) => { const reduce = (u: U, update: (u: U) => T) => { const set = (newU: U) => Object.is(u, newU) ? t : update(newU); return Object.assign( >(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }), { map: (updater: (u: U) => U) => set(updater(u)), set }); }; return reduce(t, (t: T) => t);} : (t: T) => ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: T) => T) => T; set: (newU: T) => T; } >t : T const reduce = (u: U, update: (u: U) => T) => { ->reduce : (u: U, update: (u: U) => T) => ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } ->(u: U, update: (u: U) => T) => { const set = (newU: U) => Object.is(u, newU) ? t : update(newU); return Object.assign( >(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }), { map: (updater: (u: U) => U) => set(updater(u)), set }); } : (u: U, update: (u: U) => T) => ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } +>reduce : (u: U, update: (u: U) => T) => ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } +>(u: U, update: (u: U) => T) => { const set = (newU: U) => Object.is(u, newU) ? t : update(newU); return Object.assign( >(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }), { map: (updater: (u: U) => U) => set(updater(u)), set }); } : (u: U, update: (u: U) => T) => ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } >u : U >update : (u: U) => T >u : U @@ -40,18 +40,18 @@ export const updateIfChanged = (t: T) => { >newU : U return Object.assign( ->Object.assign( >(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }), { map: (updater: (u: U) => U) => set(updater(u)), set }) : ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } +>Object.assign( >(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }), { map: (updater: (u: U) => U) => set(updater(u)), set }) : ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } >Object.assign : { (target: T_1, source: U_1): T_1 & U_1; (target: T_1, source1: U_1, source2: V): T_1 & U_1 & V; (target: T_1, source1: U_1, source2: V, source3: W): T_1 & U_1 & V & W; (target: object, ...sources: any[]): any; } >Object : ObjectConstructor >assign : { (target: T_1, source: U_1): T_1 & U_1; (target: T_1, source1: U_1, source2: V): T_1 & U_1 & V; (target: T_1, source1: U_1, source2: V, source3: W): T_1 & U_1 & V & W; (target: object, ...sources: any[]): any; } >(key: K) => ->>(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }) : (key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; } +>>(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }) : (key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; } >key : K reduce>(u[key as keyof U] as Value, (v: Value) => { ->reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }) : (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => (>>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>>) => Value>>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; } ->reduce : (u: U, update: (u: U) => T) => ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } +>reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }) : (>(key: K) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => (>>>>>>>>>>>(key: K_11) => any & { map: (updater: (u: Value>>>>>>>>>>>) => Value>>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; } +>reduce : (u: U, update: (u: U) => T) => ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } >u[key as keyof U] as Value : Value >u[key as keyof U] : U[keyof U] >u : U @@ -97,8 +97,8 @@ export const updateIfChanged = (t: T) => { }; return reduce(t, (t: T) => t); ->reduce(t, (t: T) => t) : ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: T) => T) => T; set: (newU: T) => T; } ->reduce : (u: U, update: (u: U) => T) => ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } +>reduce(t, (t: T) => t) : ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: T) => T) => T; set: (newU: T) => T; } +>reduce : (u: U, update: (u: U) => T) => ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } >t : T >(t: T) => t : (t: T) => T >t : T @@ -109,25 +109,25 @@ export const updateIfChanged = (t: T) => { // example from https://github.com/microsoft/TypeScript/issues/31605 export const testRecFun = (parent: T) => { ->testRecFun : (parent: T) => { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U) => { result: T & U_1 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } ->(parent: T) => { return { result: parent, deeper: (child: U) => testRecFun({ ...parent, ...child }) };} : (parent: T) => { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U) => { result: T & U_1 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } +>testRecFun : (parent: T) => { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U_1) => { result: T & U & U_1; deeper: (child: U_2) => { result: T & U & U_1 & U_2; deeper: (child: U_3) => { result: T & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: T & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } +>(parent: T) => { return { result: parent, deeper: (child: U) => testRecFun({ ...parent, ...child }) };} : (parent: T) => { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U_1) => { result: T & U & U_1; deeper: (child: U_2) => { result: T & U & U_1 & U_2; deeper: (child: U_3) => { result: T & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: T & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } >parent : T return { ->{ result: parent, deeper: (child: U) => testRecFun({ ...parent, ...child }) } : { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U) => { result: T & U_1 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } +>{ result: parent, deeper: (child: U) => testRecFun({ ...parent, ...child }) } : { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U_1) => { result: T & U & U_1; deeper: (child: U_2) => { result: T & U & U_1 & U_2; deeper: (child: U_3) => { result: T & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: T & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } result: parent, >result : T >parent : T deeper: (child: U) => ->deeper : (child: U) => { result: T & U; deeper: (child: U) => { result: T & U_1 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10 & U; deeper: any; }; }; }; }; }; }; }; }; }; }; } ->(child: U) => testRecFun({ ...parent, ...child }) : (child: U) => { result: T & U; deeper: (child: U) => { result: T & U_1 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10 & U; deeper: any; }; }; }; }; }; }; }; }; }; }; } +>deeper : (child: U) => { result: T & U; deeper: (child: U_1) => { result: T & U & U_1; deeper: (child: U_2) => { result: T & U & U_1 & U_2; deeper: (child: U_3) => { result: T & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: T & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10; deeper: any; }; }; }; }; }; }; }; }; }; }; } +>(child: U) => testRecFun({ ...parent, ...child }) : (child: U) => { result: T & U; deeper: (child: U_1) => { result: T & U & U_1; deeper: (child: U_2) => { result: T & U & U_1 & U_2; deeper: (child: U_3) => { result: T & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: T & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10; deeper: any; }; }; }; }; }; }; }; }; }; }; } >child : U testRecFun({ ...parent, ...child }) ->testRecFun({ ...parent, ...child }) : { result: T & U; deeper: (child: U) => { result: T & U_1 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } ->testRecFun : (parent: T) => { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U) => { result: T & U_1 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } +>testRecFun({ ...parent, ...child }) : { result: T & U; deeper: (child: U_1) => { result: T & U & U_1; deeper: (child: U_2) => { result: T & U & U_1 & U_2; deeper: (child: U_3) => { result: T & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: T & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10; deeper: (child: U_11) => any; }; }; }; }; }; }; }; }; }; }; } +>testRecFun : (parent: T) => { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U_1) => { result: T & U & U_1; deeper: (child: U_2) => { result: T & U & U_1 & U_2; deeper: (child: U_3) => { result: T & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: T & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } >{ ...parent, ...child } : T & U >parent : T >child : U @@ -137,9 +137,9 @@ export const testRecFun = (parent: T) => { let p1 = testRecFun({ one: '1' }) ->p1 : { result: { one: string; }; deeper: (child: U) => { result: { one: string; } & U; deeper: (child: U) => { result: { one: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } ->testRecFun({ one: '1' }) : { result: { one: string; }; deeper: (child: U) => { result: { one: string; } & U; deeper: (child: U) => { result: { one: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } ->testRecFun : (parent: T) => { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U) => { result: T & U_1 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } +>p1 : { result: { one: string; }; deeper: (child: U) => { result: { one: string; } & U; deeper: (child: U_1) => { result: { one: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } +>testRecFun({ one: '1' }) : { result: { one: string; }; deeper: (child: U) => { result: { one: string; } & U; deeper: (child: U_1) => { result: { one: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } +>testRecFun : (parent: T) => { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U_1) => { result: T & U & U_1; deeper: (child: U_2) => { result: T & U & U_1 & U_2; deeper: (child: U_3) => { result: T & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: T & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } >{ one: '1' } : { one: string; } >one : string >'1' : "1" @@ -148,16 +148,16 @@ void p1.result.one; >void p1.result.one : undefined >p1.result.one : string >p1.result : { one: string; } ->p1 : { result: { one: string; }; deeper: (child: U) => { result: { one: string; } & U; deeper: (child: U) => { result: { one: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } +>p1 : { result: { one: string; }; deeper: (child: U) => { result: { one: string; } & U; deeper: (child: U_1) => { result: { one: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } >result : { one: string; } >one : string let p2 = p1.deeper({ two: '2' }) ->p2 : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } ->p1.deeper({ two: '2' }) : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } ->p1.deeper : (child: U) => { result: { one: string; } & U; deeper: (child: U) => { result: { one: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10 & U; deeper: any; }; }; }; }; }; }; }; }; }; }; } ->p1 : { result: { one: string; }; deeper: (child: U) => { result: { one: string; } & U; deeper: (child: U) => { result: { one: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } ->deeper : (child: U) => { result: { one: string; } & U; deeper: (child: U) => { result: { one: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10 & U; deeper: any; }; }; }; }; }; }; }; }; }; }; } +>p2 : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } +>p1.deeper({ two: '2' }) : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } +>p1.deeper : (child: U) => { result: { one: string; } & U; deeper: (child: U_1) => { result: { one: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10; deeper: any; }; }; }; }; }; }; }; }; }; }; } +>p1 : { result: { one: string; }; deeper: (child: U) => { result: { one: string; } & U; deeper: (child: U_1) => { result: { one: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } +>deeper : (child: U) => { result: { one: string; } & U; deeper: (child: U_1) => { result: { one: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10; deeper: any; }; }; }; }; }; }; }; }; }; }; } >{ two: '2' } : { two: string; } >two : string >'2' : "2" @@ -166,7 +166,7 @@ void p2.result.one; >void p2.result.one : undefined >p2.result.one : string >p2.result : { one: string; } & { two: string; } ->p2 : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } +>p2 : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } >result : { one: string; } & { two: string; } >one : string @@ -174,16 +174,16 @@ void p2.result.two; >void p2.result.two : undefined >p2.result.two : string >p2.result : { one: string; } & { two: string; } ->p2 : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } +>p2 : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } >result : { one: string; } & { two: string; } >two : string let p3 = p2.deeper({ three: '3' }) ->p3 : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } ->p2.deeper({ three: '3' }) : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } ->p2.deeper : (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10 & U; deeper: any; }; }; }; }; }; }; }; }; }; }; } ->p2 : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } ->deeper : (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10 & U; deeper: any; }; }; }; }; }; }; }; }; }; }; } +>p3 : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } +>p2.deeper({ three: '3' }) : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } +>p2.deeper : (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10; deeper: any; }; }; }; }; }; }; }; }; }; }; } +>p2 : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } +>deeper : (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10; deeper: any; }; }; }; }; }; }; }; }; }; }; } >{ three: '3' } : { three: string; } >three : string >'3' : "3" @@ -192,7 +192,7 @@ void p3.result.one; >void p3.result.one : undefined >p3.result.one : string >p3.result : { one: string; } & { two: string; } & { three: string; } ->p3 : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } +>p3 : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } >result : { one: string; } & { two: string; } & { three: string; } >one : string @@ -200,7 +200,7 @@ void p3.result.two; >void p3.result.two : undefined >p3.result.two : string >p3.result : { one: string; } & { two: string; } & { three: string; } ->p3 : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } +>p3 : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } >result : { one: string; } & { two: string; } & { three: string; } >two : string @@ -208,7 +208,7 @@ void p3.result.three; >void p3.result.three : undefined >p3.result.three : string >p3.result : { one: string; } & { two: string; } & { three: string; } ->p3 : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } +>p3 : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } >result : { one: string; } & { two: string; } & { three: string; } >three : string diff --git a/testdata/baselines/reference/submodule/compiler/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.types.diff b/testdata/baselines/reference/submodule/compiler/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.types.diff index 097bde2dbd..b4d6568381 100644 --- a/testdata/baselines/reference/submodule/compiler/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.types.diff +++ b/testdata/baselines/reference/submodule/compiler/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.types.diff @@ -1,181 +1,44 @@ --- old.declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.types +++ new.declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.types -@@= skipped -11, +11 lines =@@ - >Value : Value - - export const updateIfChanged = (t: T) => { -->updateIfChanged : (t: T) => ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: T) => T) => T; set: (newU: T) => T; } -->(t: T) => { const reduce = (u: U, update: (u: U) => T) => { const set = (newU: U) => Object.is(u, newU) ? t : update(newU); return Object.assign( >(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }), { map: (updater: (u: U) => U) => set(updater(u)), set }); }; return reduce(t, (t: T) => t);} : (t: T) => ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: T) => T) => T; set: (newU: T) => T; } -+>updateIfChanged : (t: T) => ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: T) => T) => T; set: (newU: T) => T; } -+>(t: T) => { const reduce = (u: U, update: (u: U) => T) => { const set = (newU: U) => Object.is(u, newU) ? t : update(newU); return Object.assign( >(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }), { map: (updater: (u: U) => U) => set(updater(u)), set }); }; return reduce(t, (t: T) => t);} : (t: T) => ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: T) => T) => T; set: (newU: T) => T; } +@@= skipped -16, +16 lines =@@ >t : T const reduce = (u: U, update: (u: U) => T) => { ->reduce : (u: U, update: (u: U) => T) => (>(key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } ->(u: U, update: (u: U) => T) => { const set = (newU: U) => Object.is(u, newU) ? t : update(newU); return Object.assign( >(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }), { map: (updater: (u: U) => U) => set(updater(u)), set }); } : (u: U, update: (u: U) => T) => (>(key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } -+>reduce : (u: U, update: (u: U) => T) => ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } -+>(u: U, update: (u: U) => T) => { const set = (newU: U) => Object.is(u, newU) ? t : update(newU); return Object.assign( >(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }), { map: (updater: (u: U) => U) => set(updater(u)), set }); } : (u: U, update: (u: U) => T) => ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } ++>reduce : (u: U, update: (u: U) => T) => ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } ++>(u: U, update: (u: U) => T) => { const set = (newU: U) => Object.is(u, newU) ? t : update(newU); return Object.assign( >(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }), { map: (updater: (u: U) => U) => set(updater(u)), set }); } : (u: U, update: (u: U) => T) => ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } >u : U >update : (u: U) => T >u : U -@@= skipped -28, +28 lines =@@ +@@= skipped -23, +23 lines =@@ >newU : U return Object.assign( ->Object.assign( >(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }), { map: (updater: (u: U) => U) => set(updater(u)), set }) : (>(key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } -+>Object.assign( >(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }), { map: (updater: (u: U) => U) => set(updater(u)), set }) : ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } ++>Object.assign( >(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }), { map: (updater: (u: U) => U) => set(updater(u)), set }) : ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } >Object.assign : { (target: T_1, source: U_1): T_1 & U_1; (target: T_1, source1: U_1, source2: V): T_1 & U_1 & V; (target: T_1, source1: U_1, source2: V, source3: W): T_1 & U_1 & V & W; (target: object, ...sources: any[]): any; } >Object : ObjectConstructor >assign : { (target: T_1, source: U_1): T_1 & U_1; (target: T_1, source1: U_1, source2: V): T_1 & U_1 & V; (target: T_1, source1: U_1, source2: V, source3: W): T_1 & U_1 & V & W; (target: object, ...sources: any[]): any; } >(key: K) => ->>(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }) : >(key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; } -+>>(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }) : (key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; } ++>>(key: K) => reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }) : (key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; } >key : K reduce>(u[key as keyof U] as Value, (v: Value) => { -->reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }) : (>(key: K) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => (>>>>>>>>>>>(key: K_11) => any & { map: (updater: (u: Value>>>>>>>>>>>) => Value>>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; } + >reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }) : (>(key: K) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => (>>>>>>>>>>>(key: K_11) => any & { map: (updater: (u: Value>>>>>>>>>>>) => Value>>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; } ->reduce : (u: U, update: (u: U) => T) => (>(key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } -+>reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }) : (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => (>>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>>) => Value>>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; } -+>reduce : (u: U, update: (u: U) => T) => ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } ++>reduce : (u: U, update: (u: U) => T) => ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } >u[key as keyof U] as Value : Value >u[key as keyof U] : U[keyof U] >u : U -@@= skipped -57, +57 lines =@@ - +@@= skipped -58, +58 lines =@@ }; return reduce(t, (t: T) => t); -->reduce(t, (t: T) => t) : ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: T) => T) => T; set: (newU: T) => T; } + >reduce(t, (t: T) => t) : ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: T) => T) => T; set: (newU: T) => T; } ->reduce : (u: U, update: (u: U) => T) => (>(key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } -+>reduce(t, (t: T) => t) : ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: T) => T) => T; set: (newU: T) => T; } -+>reduce : (u: U, update: (u: U) => T) => ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } ++>reduce : (u: U, update: (u: U) => T) => ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } >t : T >(t: T) => t : (t: T) => T - >t : T -@@= skipped -12, +12 lines =@@ - // example from https://github.com/microsoft/TypeScript/issues/31605 - - export const testRecFun = (parent: T) => { -->testRecFun : (parent: T) => { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U_1) => { result: T & U & U_1; deeper: (child: U_2) => { result: T & U & U_1 & U_2; deeper: (child: U_3) => { result: T & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: T & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -->(parent: T) => { return { result: parent, deeper: (child: U) => testRecFun({ ...parent, ...child }) };} : (parent: T) => { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U_1) => { result: T & U & U_1; deeper: (child: U_2) => { result: T & U & U_1 & U_2; deeper: (child: U_3) => { result: T & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: T & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -+>testRecFun : (parent: T) => { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U) => { result: T & U_1 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } -+>(parent: T) => { return { result: parent, deeper: (child: U) => testRecFun({ ...parent, ...child }) };} : (parent: T) => { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U) => { result: T & U_1 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } - >parent : T - - return { -->{ result: parent, deeper: (child: U) => testRecFun({ ...parent, ...child }) } : { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U_1) => { result: T & U & U_1; deeper: (child: U_2) => { result: T & U & U_1 & U_2; deeper: (child: U_3) => { result: T & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: T & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -+>{ result: parent, deeper: (child: U) => testRecFun({ ...parent, ...child }) } : { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U) => { result: T & U_1 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } - - result: parent, - >result : T - >parent : T - - deeper: (child: U) => -->deeper : (child: U) => { result: T & U; deeper: (child: U_1) => { result: T & U & U_1; deeper: (child: U_2) => { result: T & U & U_1 & U_2; deeper: (child: U_3) => { result: T & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: T & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10; deeper: any; }; }; }; }; }; }; }; }; }; }; } -->(child: U) => testRecFun({ ...parent, ...child }) : (child: U) => { result: T & U; deeper: (child: U_1) => { result: T & U & U_1; deeper: (child: U_2) => { result: T & U & U_1 & U_2; deeper: (child: U_3) => { result: T & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: T & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10; deeper: any; }; }; }; }; }; }; }; }; }; }; } -+>deeper : (child: U) => { result: T & U; deeper: (child: U) => { result: T & U_1 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10 & U; deeper: any; }; }; }; }; }; }; }; }; }; }; } -+>(child: U) => testRecFun({ ...parent, ...child }) : (child: U) => { result: T & U; deeper: (child: U) => { result: T & U_1 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10 & U; deeper: any; }; }; }; }; }; }; }; }; }; }; } - >child : U - - testRecFun({ ...parent, ...child }) -->testRecFun({ ...parent, ...child }) : { result: T & U; deeper: (child: U_1) => { result: T & U & U_1; deeper: (child: U_2) => { result: T & U & U_1 & U_2; deeper: (child: U_3) => { result: T & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: T & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10; deeper: (child: U_11) => any; }; }; }; }; }; }; }; }; }; }; } -->testRecFun : (parent: T) => { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U_1) => { result: T & U & U_1; deeper: (child: U_2) => { result: T & U & U_1 & U_2; deeper: (child: U_3) => { result: T & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: T & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -+>testRecFun({ ...parent, ...child }) : { result: T & U; deeper: (child: U) => { result: T & U_1 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } -+>testRecFun : (parent: T) => { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U) => { result: T & U_1 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } - >{ ...parent, ...child } : T & U - >parent : T - >child : U -@@= skipped -28, +28 lines =@@ - - - let p1 = testRecFun({ one: '1' }) -->p1 : { result: { one: string; }; deeper: (child: U) => { result: { one: string; } & U; deeper: (child: U_1) => { result: { one: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -->testRecFun({ one: '1' }) : { result: { one: string; }; deeper: (child: U) => { result: { one: string; } & U; deeper: (child: U_1) => { result: { one: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -->testRecFun : (parent: T) => { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U_1) => { result: T & U & U_1; deeper: (child: U_2) => { result: T & U & U_1 & U_2; deeper: (child: U_3) => { result: T & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: T & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -+>p1 : { result: { one: string; }; deeper: (child: U) => { result: { one: string; } & U; deeper: (child: U) => { result: { one: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } -+>testRecFun({ one: '1' }) : { result: { one: string; }; deeper: (child: U) => { result: { one: string; } & U; deeper: (child: U) => { result: { one: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } -+>testRecFun : (parent: T) => { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U) => { result: T & U_1 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: T & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } - >{ one: '1' } : { one: string; } - >one : string - >'1' : "1" -@@= skipped -11, +11 lines =@@ - >void p1.result.one : undefined - >p1.result.one : string - >p1.result : { one: string; } -->p1 : { result: { one: string; }; deeper: (child: U) => { result: { one: string; } & U; deeper: (child: U_1) => { result: { one: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -+>p1 : { result: { one: string; }; deeper: (child: U) => { result: { one: string; } & U; deeper: (child: U) => { result: { one: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } - >result : { one: string; } - >one : string - - let p2 = p1.deeper({ two: '2' }) -->p2 : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -->p1.deeper({ two: '2' }) : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -->p1.deeper : (child: U) => { result: { one: string; } & U; deeper: (child: U_1) => { result: { one: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10; deeper: any; }; }; }; }; }; }; }; }; }; }; } -->p1 : { result: { one: string; }; deeper: (child: U) => { result: { one: string; } & U; deeper: (child: U_1) => { result: { one: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -->deeper : (child: U) => { result: { one: string; } & U; deeper: (child: U_1) => { result: { one: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => { result: { one: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10; deeper: any; }; }; }; }; }; }; }; }; }; }; } -+>p2 : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } -+>p1.deeper({ two: '2' }) : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } -+>p1.deeper : (child: U) => { result: { one: string; } & U; deeper: (child: U) => { result: { one: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10 & U; deeper: any; }; }; }; }; }; }; }; }; }; }; } -+>p1 : { result: { one: string; }; deeper: (child: U) => { result: { one: string; } & U; deeper: (child: U) => { result: { one: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } -+>deeper : (child: U) => { result: { one: string; } & U; deeper: (child: U) => { result: { one: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => { result: { one: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10 & U; deeper: any; }; }; }; }; }; }; }; }; }; }; } - >{ two: '2' } : { two: string; } - >two : string - >'2' : "2" -@@= skipped -18, +18 lines =@@ - >void p2.result.one : undefined - >p2.result.one : string - >p2.result : { one: string; } & { two: string; } -->p2 : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -+>p2 : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } - >result : { one: string; } & { two: string; } - >one : string - -@@= skipped -8, +8 lines =@@ - >void p2.result.two : undefined - >p2.result.two : string - >p2.result : { one: string; } & { two: string; } -->p2 : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -+>p2 : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } - >result : { one: string; } & { two: string; } - >two : string - - let p3 = p2.deeper({ three: '3' }) -->p3 : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -->p2.deeper({ three: '3' }) : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -->p2.deeper : (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10; deeper: any; }; }; }; }; }; }; }; }; }; }; } -->p2 : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -->deeper : (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => { result: { one: string; } & { two: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10; deeper: any; }; }; }; }; }; }; }; }; }; }; } -+>p3 : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } -+>p2.deeper({ three: '3' }) : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } -+>p2.deeper : (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10 & U; deeper: any; }; }; }; }; }; }; }; }; }; }; } -+>p2 : { result: { one: string; } & { two: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } -+>deeper : (child: U) => { result: { one: string; } & { two: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10 & U; deeper: any; }; }; }; }; }; }; }; }; }; }; } - >{ three: '3' } : { three: string; } - >three : string - >'3' : "3" -@@= skipped -18, +18 lines =@@ - >void p3.result.one : undefined - >p3.result.one : string - >p3.result : { one: string; } & { two: string; } & { three: string; } -->p3 : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -+>p3 : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } - >result : { one: string; } & { two: string; } & { three: string; } - >one : string - -@@= skipped -8, +8 lines =@@ - >void p3.result.two : undefined - >p3.result.two : string - >p3.result : { one: string; } & { two: string; } & { three: string; } -->p3 : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -+>p3 : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } - >result : { one: string; } & { two: string; } & { three: string; } - >two : string - -@@= skipped -8, +8 lines =@@ - >void p3.result.three : undefined - >p3.result.three : string - >p3.result : { one: string; } & { two: string; } & { three: string; } -->p3 : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U_1) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1; deeper: (child: U_2) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2; deeper: (child: U_3) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: { one: string; } & { two: string; } & { three: string; } & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } -+>p3 : { result: { one: string; } & { two: string; } & { three: string; }; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U; deeper: (child: U) => { result: { one: string; } & { two: string; } & { three: string; } & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } - >result : { one: string; } & { two: string; } & { three: string; } - >three : string + >t : T \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/decoratorUsedBeforeDeclaration.errors.txt b/testdata/baselines/reference/submodule/compiler/decoratorUsedBeforeDeclaration.errors.txt index a5829d2097..79e306116d 100644 --- a/testdata/baselines/reference/submodule/compiler/decoratorUsedBeforeDeclaration.errors.txt +++ b/testdata/baselines/reference/submodule/compiler/decoratorUsedBeforeDeclaration.errors.txt @@ -3,10 +3,20 @@ decoratorUsedBeforeDeclaration.ts(1,9): error TS2450: Enum 'Enum' used before it decoratorUsedBeforeDeclaration.ts(2,7): error TS2450: Enum 'Enum' used before its declaration. decoratorUsedBeforeDeclaration.ts(4,4): error TS2448: Block-scoped variable 'lambda' used before its declaration. decoratorUsedBeforeDeclaration.ts(4,11): error TS2450: Enum 'Enum' used before its declaration. +decoratorUsedBeforeDeclaration.ts(4,16): error TS2729: Property 'No' is used before its initialization. decoratorUsedBeforeDeclaration.ts(5,9): error TS2450: Enum 'Enum' used before its declaration. +decoratorUsedBeforeDeclaration.ts(5,14): error TS2729: Property 'No' is used before its initialization. +decoratorUsedBeforeDeclaration.ts(12,4): error TS2448: Block-scoped variable 'lambda' used before its declaration. +decoratorUsedBeforeDeclaration.ts(12,11): error TS2450: Enum 'Enum' used before its declaration. +decoratorUsedBeforeDeclaration.ts(13,9): error TS2450: Enum 'Enum' used before its declaration. +decoratorUsedBeforeDeclaration.ts(18,4): error TS2448: Block-scoped variable 'lambda' used before its declaration. +decoratorUsedBeforeDeclaration.ts(24,11): error TS2448: Block-scoped variable 'lambda' used before its declaration. +decoratorUsedBeforeDeclaration.ts(24,18): error TS2450: Enum 'Enum' used before its declaration. +decoratorUsedBeforeDeclaration.ts(24,33): error TS2450: Enum 'Enum' used before its declaration. +decoratorUsedBeforeDeclaration.ts(28,11): error TS2448: Block-scoped variable 'lambda' used before its declaration. -==== decoratorUsedBeforeDeclaration.ts (6 errors) ==== +==== decoratorUsedBeforeDeclaration.ts (16 errors) ==== @lambda(Enum.No) ~~~~~~ !!! error TS2448: Block-scoped variable 'lambda' used before its declaration. @@ -26,10 +36,16 @@ decoratorUsedBeforeDeclaration.ts(5,9): error TS2450: Enum 'Enum' used before it ~~~~ !!! error TS2450: Enum 'Enum' used before its declaration. !!! related TS2728 decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here. + ~~ +!!! error TS2729: Property 'No' is used before its initialization. +!!! related TS2728 decoratorUsedBeforeDeclaration.ts:36:3: 'No' is declared here. @deco(Enum.No) ~~~~ !!! error TS2450: Enum 'Enum' used before its declaration. !!! related TS2728 decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here. + ~~ +!!! error TS2729: Property 'No' is used before its initialization. +!!! related TS2728 decoratorUsedBeforeDeclaration.ts:36:3: 'No' is declared here. greeting: string; constructor(message: string) { @@ -37,22 +53,46 @@ decoratorUsedBeforeDeclaration.ts(5,9): error TS2450: Enum 'Enum' used before it } @lambda(Enum.No) + ~~~~~~ +!!! error TS2448: Block-scoped variable 'lambda' used before its declaration. +!!! related TS2728 decoratorUsedBeforeDeclaration.ts:40:7: 'lambda' is declared here. + ~~~~ +!!! error TS2450: Enum 'Enum' used before its declaration. +!!! related TS2728 decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here. @deco(Enum.No) + ~~~~ +!!! error TS2450: Enum 'Enum' used before its declaration. +!!! related TS2728 decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here. greet() { return "Hello, " + this.greeting; } @lambda + ~~~~~~ +!!! error TS2448: Block-scoped variable 'lambda' used before its declaration. +!!! related TS2728 decoratorUsedBeforeDeclaration.ts:40:7: 'lambda' is declared here. @deco greet1() { return "Hello, " + this.greeting; } greet2(@lambda(Enum.No) @deco(Enum.No) param) { + ~~~~~~ +!!! error TS2448: Block-scoped variable 'lambda' used before its declaration. +!!! related TS2728 decoratorUsedBeforeDeclaration.ts:40:7: 'lambda' is declared here. + ~~~~ +!!! error TS2450: Enum 'Enum' used before its declaration. +!!! related TS2728 decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here. + ~~~~ +!!! error TS2450: Enum 'Enum' used before its declaration. +!!! related TS2728 decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here. return "Hello, " + this.greeting; } greet3(@lambda @deco param) { + ~~~~~~ +!!! error TS2448: Block-scoped variable 'lambda' used before its declaration. +!!! related TS2728 decoratorUsedBeforeDeclaration.ts:40:7: 'lambda' is declared here. return "Hello, " + this.greeting; } } diff --git a/testdata/baselines/reference/submodule/compiler/decoratorUsedBeforeDeclaration.errors.txt.diff b/testdata/baselines/reference/submodule/compiler/decoratorUsedBeforeDeclaration.errors.txt.diff deleted file mode 100644 index 56dfc89192..0000000000 --- a/testdata/baselines/reference/submodule/compiler/decoratorUsedBeforeDeclaration.errors.txt.diff +++ /dev/null @@ -1,90 +0,0 @@ ---- old.decoratorUsedBeforeDeclaration.errors.txt -+++ new.decoratorUsedBeforeDeclaration.errors.txt -@@= skipped -2, +2 lines =@@ - decoratorUsedBeforeDeclaration.ts(2,7): error TS2450: Enum 'Enum' used before its declaration. - decoratorUsedBeforeDeclaration.ts(4,4): error TS2448: Block-scoped variable 'lambda' used before its declaration. - decoratorUsedBeforeDeclaration.ts(4,11): error TS2450: Enum 'Enum' used before its declaration. --decoratorUsedBeforeDeclaration.ts(4,16): error TS2729: Property 'No' is used before its initialization. - decoratorUsedBeforeDeclaration.ts(5,9): error TS2450: Enum 'Enum' used before its declaration. --decoratorUsedBeforeDeclaration.ts(5,14): error TS2729: Property 'No' is used before its initialization. --decoratorUsedBeforeDeclaration.ts(12,4): error TS2448: Block-scoped variable 'lambda' used before its declaration. --decoratorUsedBeforeDeclaration.ts(12,11): error TS2450: Enum 'Enum' used before its declaration. --decoratorUsedBeforeDeclaration.ts(13,9): error TS2450: Enum 'Enum' used before its declaration. --decoratorUsedBeforeDeclaration.ts(18,4): error TS2448: Block-scoped variable 'lambda' used before its declaration. --decoratorUsedBeforeDeclaration.ts(24,11): error TS2448: Block-scoped variable 'lambda' used before its declaration. --decoratorUsedBeforeDeclaration.ts(24,18): error TS2450: Enum 'Enum' used before its declaration. --decoratorUsedBeforeDeclaration.ts(24,33): error TS2450: Enum 'Enum' used before its declaration. --decoratorUsedBeforeDeclaration.ts(28,11): error TS2448: Block-scoped variable 'lambda' used before its declaration. -- -- --==== decoratorUsedBeforeDeclaration.ts (16 errors) ==== -+ -+ -+==== decoratorUsedBeforeDeclaration.ts (6 errors) ==== - @lambda(Enum.No) - ~~~~~~ - !!! error TS2448: Block-scoped variable 'lambda' used before its declaration. -@@= skipped -33, +23 lines =@@ - ~~~~ - !!! error TS2450: Enum 'Enum' used before its declaration. - !!! related TS2728 decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here. -- ~~ --!!! error TS2729: Property 'No' is used before its initialization. --!!! related TS2728 decoratorUsedBeforeDeclaration.ts:36:3: 'No' is declared here. - @deco(Enum.No) - ~~~~ - !!! error TS2450: Enum 'Enum' used before its declaration. - !!! related TS2728 decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here. -- ~~ --!!! error TS2729: Property 'No' is used before its initialization. --!!! related TS2728 decoratorUsedBeforeDeclaration.ts:36:3: 'No' is declared here. - greeting: string; - - constructor(message: string) { -@@= skipped -17, +11 lines =@@ - } - - @lambda(Enum.No) -- ~~~~~~ --!!! error TS2448: Block-scoped variable 'lambda' used before its declaration. --!!! related TS2728 decoratorUsedBeforeDeclaration.ts:40:7: 'lambda' is declared here. -- ~~~~ --!!! error TS2450: Enum 'Enum' used before its declaration. --!!! related TS2728 decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here. - @deco(Enum.No) -- ~~~~ --!!! error TS2450: Enum 'Enum' used before its declaration. --!!! related TS2728 decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here. - greet() { - return "Hello, " + this.greeting; - } - - @lambda -- ~~~~~~ --!!! error TS2448: Block-scoped variable 'lambda' used before its declaration. --!!! related TS2728 decoratorUsedBeforeDeclaration.ts:40:7: 'lambda' is declared here. - @deco - greet1() { - return "Hello, " + this.greeting; - } - - greet2(@lambda(Enum.No) @deco(Enum.No) param) { -- ~~~~~~ --!!! error TS2448: Block-scoped variable 'lambda' used before its declaration. --!!! related TS2728 decoratorUsedBeforeDeclaration.ts:40:7: 'lambda' is declared here. -- ~~~~ --!!! error TS2450: Enum 'Enum' used before its declaration. --!!! related TS2728 decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here. -- ~~~~ --!!! error TS2450: Enum 'Enum' used before its declaration. --!!! related TS2728 decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here. - return "Hello, " + this.greeting; - } - - greet3(@lambda @deco param) { -- ~~~~~~ --!!! error TS2448: Block-scoped variable 'lambda' used before its declaration. --!!! related TS2728 decoratorUsedBeforeDeclaration.ts:40:7: 'lambda' is declared here. - return "Hello, " + this.greeting; - } - } \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/disallowedBlockScopedInPresenceOfParseErrors1.errors.txt b/testdata/baselines/reference/submodule/compiler/disallowedBlockScopedInPresenceOfParseErrors1.errors.txt index 7670e9c436..9839a817fc 100644 --- a/testdata/baselines/reference/submodule/compiler/disallowedBlockScopedInPresenceOfParseErrors1.errors.txt +++ b/testdata/baselines/reference/submodule/compiler/disallowedBlockScopedInPresenceOfParseErrors1.errors.txt @@ -1,19 +1,25 @@ +disallowedBlockScopedInPresenceOfParseErrors1.ts(5,5): error TS1156: 'const' declarations can only be declared inside a block. disallowedBlockScopedInPresenceOfParseErrors1.ts(6,17): error TS2454: Variable 'e' is used before being assigned. disallowedBlockScopedInPresenceOfParseErrors1.ts(8,1): error TS1128: Declaration or statement expected. +disallowedBlockScopedInPresenceOfParseErrors1.ts(12,5): error TS1156: 'let' declarations can only be declared inside a block. disallowedBlockScopedInPresenceOfParseErrors1.ts(13,17): error TS2454: Variable 'e' is used before being assigned. disallowedBlockScopedInPresenceOfParseErrors1.ts(15,1): error TS1128: Declaration or statement expected. +disallowedBlockScopedInPresenceOfParseErrors1.ts(21,5): error TS1156: 'using' declarations can only be declared inside a block. disallowedBlockScopedInPresenceOfParseErrors1.ts(22,17): error TS2454: Variable 'e' is used before being assigned. disallowedBlockScopedInPresenceOfParseErrors1.ts(24,1): error TS1128: Declaration or statement expected. +disallowedBlockScopedInPresenceOfParseErrors1.ts(30,5): error TS1156: 'await using' declarations can only be declared inside a block. disallowedBlockScopedInPresenceOfParseErrors1.ts(31,17): error TS2454: Variable 'e' is used before being assigned. disallowedBlockScopedInPresenceOfParseErrors1.ts(33,1): error TS1128: Declaration or statement expected. -==== disallowedBlockScopedInPresenceOfParseErrors1.ts (8 errors) ==== +==== disallowedBlockScopedInPresenceOfParseErrors1.ts (12 errors) ==== // https://github.com/microsoft/TypeScript/issues/61734 function f1() { if (1 > 0) const e = 3; + ~~~~~~~~~~~~ +!!! error TS1156: 'const' declarations can only be declared inside a block. console.log(e); ~ !!! error TS2454: Variable 'e' is used before being assigned. @@ -25,6 +31,8 @@ disallowedBlockScopedInPresenceOfParseErrors1.ts(33,1): error TS1128: Declaratio function f2() { if (1 > 0) let e = 3; + ~~~~~~~~~~ +!!! error TS1156: 'let' declarations can only be declared inside a block. console.log(e); ~ !!! error TS2454: Variable 'e' is used before being assigned. @@ -38,6 +46,8 @@ disallowedBlockScopedInPresenceOfParseErrors1.ts(33,1): error TS1128: Declaratio function f3() { if (1 > 0) using e = resource; + ~~~~~~~~~~~~~~~~~~~ +!!! error TS1156: 'using' declarations can only be declared inside a block. console.log(e); ~ !!! error TS2454: Variable 'e' is used before being assigned. @@ -51,6 +61,8 @@ disallowedBlockScopedInPresenceOfParseErrors1.ts(33,1): error TS1128: Declaratio async function f4() { if (1 > 0) await using e = asyncResource; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS1156: 'await using' declarations can only be declared inside a block. console.log(e); ~ !!! error TS2454: Variable 'e' is used before being assigned. diff --git a/testdata/baselines/reference/submodule/compiler/disallowedBlockScopedInPresenceOfParseErrors1.errors.txt.diff b/testdata/baselines/reference/submodule/compiler/disallowedBlockScopedInPresenceOfParseErrors1.errors.txt.diff deleted file mode 100644 index 85cd19ea87..0000000000 --- a/testdata/baselines/reference/submodule/compiler/disallowedBlockScopedInPresenceOfParseErrors1.errors.txt.diff +++ /dev/null @@ -1,56 +0,0 @@ ---- old.disallowedBlockScopedInPresenceOfParseErrors1.errors.txt -+++ new.disallowedBlockScopedInPresenceOfParseErrors1.errors.txt -@@= skipped -0, +0 lines =@@ --disallowedBlockScopedInPresenceOfParseErrors1.ts(5,5): error TS1156: 'const' declarations can only be declared inside a block. - disallowedBlockScopedInPresenceOfParseErrors1.ts(6,17): error TS2454: Variable 'e' is used before being assigned. - disallowedBlockScopedInPresenceOfParseErrors1.ts(8,1): error TS1128: Declaration or statement expected. --disallowedBlockScopedInPresenceOfParseErrors1.ts(12,5): error TS1156: 'let' declarations can only be declared inside a block. - disallowedBlockScopedInPresenceOfParseErrors1.ts(13,17): error TS2454: Variable 'e' is used before being assigned. - disallowedBlockScopedInPresenceOfParseErrors1.ts(15,1): error TS1128: Declaration or statement expected. --disallowedBlockScopedInPresenceOfParseErrors1.ts(21,5): error TS1156: 'using' declarations can only be declared inside a block. - disallowedBlockScopedInPresenceOfParseErrors1.ts(22,17): error TS2454: Variable 'e' is used before being assigned. - disallowedBlockScopedInPresenceOfParseErrors1.ts(24,1): error TS1128: Declaration or statement expected. --disallowedBlockScopedInPresenceOfParseErrors1.ts(30,5): error TS1156: 'await using' declarations can only be declared inside a block. - disallowedBlockScopedInPresenceOfParseErrors1.ts(31,17): error TS2454: Variable 'e' is used before being assigned. - disallowedBlockScopedInPresenceOfParseErrors1.ts(33,1): error TS1128: Declaration or statement expected. - - --==== disallowedBlockScopedInPresenceOfParseErrors1.ts (12 errors) ==== -+==== disallowedBlockScopedInPresenceOfParseErrors1.ts (8 errors) ==== - // https://github.com/microsoft/TypeScript/issues/61734 - - function f1() { - if (1 > 0) - const e = 3; -- ~~~~~~~~~~~~ --!!! error TS1156: 'const' declarations can only be declared inside a block. - console.log(e); - ~ - !!! error TS2454: Variable 'e' is used before being assigned. -@@= skipped -30, +24 lines =@@ - function f2() { - if (1 > 0) - let e = 3; -- ~~~~~~~~~~ --!!! error TS1156: 'let' declarations can only be declared inside a block. - console.log(e); - ~ - !!! error TS2454: Variable 'e' is used before being assigned. -@@= skipped -15, +13 lines =@@ - function f3() { - if (1 > 0) - using e = resource; -- ~~~~~~~~~~~~~~~~~~~ --!!! error TS1156: 'using' declarations can only be declared inside a block. - console.log(e); - ~ - !!! error TS2454: Variable 'e' is used before being assigned. -@@= skipped -15, +13 lines =@@ - async function f4() { - if (1 > 0) - await using e = asyncResource; -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --!!! error TS1156: 'await using' declarations can only be declared inside a block. - console.log(e); - ~ - !!! error TS2454: Variable 'e' is used before being assigned. \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/enumWithBigint.errors.txt b/testdata/baselines/reference/submodule/compiler/enumWithBigint.errors.txt new file mode 100644 index 0000000000..a88660ce7c --- /dev/null +++ b/testdata/baselines/reference/submodule/compiler/enumWithBigint.errors.txt @@ -0,0 +1,10 @@ +enumWithBigint.ts(2,3): error TS2452: An enum member cannot have a numeric name. + + +==== enumWithBigint.ts (1 errors) ==== + enum E { + 0n = 0, + ~~ +!!! error TS2452: An enum member cannot have a numeric name. + } + \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/enumWithBigint.errors.txt.diff b/testdata/baselines/reference/submodule/compiler/enumWithBigint.errors.txt.diff deleted file mode 100644 index 27d2dca272..0000000000 --- a/testdata/baselines/reference/submodule/compiler/enumWithBigint.errors.txt.diff +++ /dev/null @@ -1,14 +0,0 @@ ---- old.enumWithBigint.errors.txt -+++ new.enumWithBigint.errors.txt -@@= skipped -0, +0 lines =@@ --enumWithBigint.ts(2,3): error TS2452: An enum member cannot have a numeric name. -- -- --==== enumWithBigint.ts (1 errors) ==== -- enum E { -- 0n = 0, -- ~~ --!!! error TS2452: An enum member cannot have a numeric name. -- } -- -+ \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/inferFromAnnotatedReturn1.types b/testdata/baselines/reference/submodule/compiler/inferFromAnnotatedReturn1.types index 6fa55005ef..192879a21d 100644 --- a/testdata/baselines/reference/submodule/compiler/inferFromAnnotatedReturn1.types +++ b/testdata/baselines/reference/submodule/compiler/inferFromAnnotatedReturn1.types @@ -7,19 +7,19 @@ declare function test(cb: (arg: T) => T): T; >arg : T const res1 = test((arg): number => 1); // ok ->res1 : unknown ->test((arg): number => 1) : unknown +>res1 : number +>test((arg): number => 1) : number >test : (cb: (arg: T) => T) => T ->(arg): number => 1 : (arg: unknown) => number ->arg : unknown +>(arg): number => 1 : (arg: number) => number +>arg : number >1 : 1 const res2 = test((arg): number => 'foo'); // error ->res2 : unknown ->test((arg): number => 'foo') : unknown +>res2 : number +>test((arg): number => 'foo') : number >test : (cb: (arg: T) => T) => T ->(arg): number => 'foo' : (arg: unknown) => number ->arg : unknown +>(arg): number => 'foo' : (arg: number) => number +>arg : number >'foo' : "foo" export declare function linkedSignal(options: { @@ -36,10 +36,10 @@ export declare function linkedSignal(options: { }): D; const signal = linkedSignal({ ->signal : unknown ->linkedSignal({ source: () => 3, computation: (s): number => 3,}) : unknown +>signal : number +>linkedSignal({ source: () => 3, computation: (s): number => 3,}) : number >linkedSignal : (options: { source: () => S; computation: (source: NoInfer) => D; }) => D ->{ source: () => 3, computation: (s): number => 3,} : { source: () => number; computation: (s: unknown) => number; } +>{ source: () => 3, computation: (s): number => 3,} : { source: () => number; computation: (s: number) => number; } source: () => 3, >source : () => number @@ -47,9 +47,9 @@ const signal = linkedSignal({ >3 : 3 computation: (s): number => 3, ->computation : (s: unknown) => number ->(s): number => 3 : (s: unknown) => number ->s : unknown +>computation : (s: number) => number +>(s): number => 3 : (s: number) => number +>s : number >3 : 3 }); @@ -66,10 +66,10 @@ class Foo { } const _1 = new Foo((name: string, { x }): { name: string; x: number } => ({ ->_1 : Foo ->new Foo((name: string, { x }): { name: string; x: number } => ({ name, x,})) : Foo +>_1 : Foo +>new Foo((name: string, { x }): { name: string; x: number } => ({ name, x,})) : Foo >Foo : typeof Foo ->(name: string, { x }): { name: string; x: number } => ({ name, x,}) : (name: string, { x }: { x: number; other: unknown; }) => { name: string; x: number; } +>(name: string, { x }): { name: string; x: number } => ({ name, x,}) : (name: string, { x }: { x: number; other: NoInfer<{ name: string; x: number; }>; }) => { name: string; x: number; } >name : string >x : number >name : string diff --git a/testdata/baselines/reference/submodule/compiler/inferFromAnnotatedReturn1.types.diff b/testdata/baselines/reference/submodule/compiler/inferFromAnnotatedReturn1.types.diff deleted file mode 100644 index 762072c2e8..0000000000 --- a/testdata/baselines/reference/submodule/compiler/inferFromAnnotatedReturn1.types.diff +++ /dev/null @@ -1,71 +0,0 @@ ---- old.inferFromAnnotatedReturn1.types -+++ new.inferFromAnnotatedReturn1.types -@@= skipped -6, +6 lines =@@ - >arg : T - - const res1 = test((arg): number => 1); // ok -->res1 : number -->test((arg): number => 1) : number -+>res1 : unknown -+>test((arg): number => 1) : unknown - >test : (cb: (arg: T) => T) => T -->(arg): number => 1 : (arg: number) => number -->arg : number -+>(arg): number => 1 : (arg: unknown) => number -+>arg : unknown - >1 : 1 - - const res2 = test((arg): number => 'foo'); // error -->res2 : number -->test((arg): number => 'foo') : number -+>res2 : unknown -+>test((arg): number => 'foo') : unknown - >test : (cb: (arg: T) => T) => T -->(arg): number => 'foo' : (arg: number) => number -->arg : number -+>(arg): number => 'foo' : (arg: unknown) => number -+>arg : unknown - >'foo' : "foo" - - export declare function linkedSignal(options: { -@@= skipped -29, +29 lines =@@ - }): D; - - const signal = linkedSignal({ -->signal : number -->linkedSignal({ source: () => 3, computation: (s): number => 3,}) : number -+>signal : unknown -+>linkedSignal({ source: () => 3, computation: (s): number => 3,}) : unknown - >linkedSignal : (options: { source: () => S; computation: (source: NoInfer) => D; }) => D -->{ source: () => 3, computation: (s): number => 3,} : { source: () => number; computation: (s: number) => number; } -+>{ source: () => 3, computation: (s): number => 3,} : { source: () => number; computation: (s: unknown) => number; } - - source: () => 3, - >source : () => number -@@= skipped -11, +11 lines =@@ - >3 : 3 - - computation: (s): number => 3, -->computation : (s: number) => number -->(s): number => 3 : (s: number) => number -->s : number -+>computation : (s: unknown) => number -+>(s): number => 3 : (s: unknown) => number -+>s : unknown - >3 : 3 - - }); -@@= skipped -19, +19 lines =@@ - } - - const _1 = new Foo((name: string, { x }): { name: string; x: number } => ({ -->_1 : Foo -->new Foo((name: string, { x }): { name: string; x: number } => ({ name, x,})) : Foo -+>_1 : Foo -+>new Foo((name: string, { x }): { name: string; x: number } => ({ name, x,})) : Foo - >Foo : typeof Foo -->(name: string, { x }): { name: string; x: number } => ({ name, x,}) : (name: string, { x }: { x: number; other: NoInfer<{ name: string; x: number; }>; }) => { name: string; x: number; } -+>(name: string, { x }): { name: string; x: number } => ({ name, x,}) : (name: string, { x }: { x: number; other: unknown; }) => { name: string; x: number; } - >name : string - >x : number - >name : string \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/inlineMappedTypeModifierDeclarationEmit.js b/testdata/baselines/reference/submodule/compiler/inlineMappedTypeModifierDeclarationEmit.js index 4e74e29b74..33dc5af869 100644 --- a/testdata/baselines/reference/submodule/compiler/inlineMappedTypeModifierDeclarationEmit.js +++ b/testdata/baselines/reference/submodule/compiler/inlineMappedTypeModifierDeclarationEmit.js @@ -71,7 +71,7 @@ export declare function test1(obj: T, k: K): OmitReal export declare function test2(obj: T, k: K): OmitUnveiled; export {}; //// [index.d.ts] -export declare function wrappedTest1(obj: T, k: K): Exclude extends infer T extends keyof T_1 ? { [P in T]: T_1[P]; } : never; +export declare function wrappedTest1(obj: T, k: K): Exclude extends infer T_1 extends keyof T ? { [P in T_1]: T[P]; } : never; export declare function wrappedTest2(obj: T, k: K): { [P in Exclude]: T[P]; }; export type Obj = { a: number; @@ -83,42 +83,3 @@ export declare const processedInternally1: { export declare const processedInternally2: { foo: string; }; - - -//// [DtsFileErrors] - - -index.d.ts(1,88): error TS2304: Cannot find name 'T_1'. -index.d.ts(1,126): error TS2304: Cannot find name 'T_1'. -index.d.ts(1,144): error TS2304: Cannot find name 'T_1'. - - -==== index.d.ts (3 errors) ==== - export declare function wrappedTest1(obj: T, k: K): Exclude extends infer T extends keyof T_1 ? { [P in T]: T_1[P]; } : never; - ~~~ -!!! error TS2304: Cannot find name 'T_1'. - ~~~ -!!! error TS2304: Cannot find name 'T_1'. - ~~~ -!!! error TS2304: Cannot find name 'T_1'. - export declare function wrappedTest2(obj: T, k: K): { [P in Exclude]: T[P]; }; - export type Obj = { - a: number; - readonly foo: string; - }; - export declare const processedInternally1: { - readonly foo: string; - }; - export declare const processedInternally2: { - foo: string; - }; - -==== other.d.ts (0 errors) ==== - type OmitReal = Pick>; - type OmitUnveiled = { - [P in Exclude]: T[P]; - }; - export declare function test1(obj: T, k: K): OmitReal; - export declare function test2(obj: T, k: K): OmitUnveiled; - export {}; - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/inlineMappedTypeModifierDeclarationEmit.js.diff b/testdata/baselines/reference/submodule/compiler/inlineMappedTypeModifierDeclarationEmit.js.diff index b681d7c7c2..8a81efd1b8 100644 --- a/testdata/baselines/reference/submodule/compiler/inlineMappedTypeModifierDeclarationEmit.js.diff +++ b/testdata/baselines/reference/submodule/compiler/inlineMappedTypeModifierDeclarationEmit.js.diff @@ -8,56 +8,4 @@ +const other_1 = require("./other"); function wrappedTest1(obj, k) { return (0, other_1.test1)(obj, k); - } -@@= skipped -20, +20 lines =@@ - export declare function test2(obj: T, k: K): OmitUnveiled; - export {}; - //// [index.d.ts] --export declare function wrappedTest1(obj: T, k: K): Exclude extends infer T_1 extends keyof T ? { [P in T_1]: T[P]; } : never; -+export declare function wrappedTest1(obj: T, k: K): Exclude extends infer T extends keyof T_1 ? { [P in T]: T_1[P]; } : never; - export declare function wrappedTest2(obj: T, k: K): { [P in Exclude]: T[P]; }; - export type Obj = { - a: number; -@@= skipped -12, +12 lines =@@ - export declare const processedInternally2: { - foo: string; - }; -+ -+ -+//// [DtsFileErrors] -+ -+ -+index.d.ts(1,88): error TS2304: Cannot find name 'T_1'. -+index.d.ts(1,126): error TS2304: Cannot find name 'T_1'. -+index.d.ts(1,144): error TS2304: Cannot find name 'T_1'. -+ -+ -+==== index.d.ts (3 errors) ==== -+ export declare function wrappedTest1(obj: T, k: K): Exclude extends infer T extends keyof T_1 ? { [P in T]: T_1[P]; } : never; -+ ~~~ -+!!! error TS2304: Cannot find name 'T_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'T_1'. -+ ~~~ -+!!! error TS2304: Cannot find name 'T_1'. -+ export declare function wrappedTest2(obj: T, k: K): { [P in Exclude]: T[P]; }; -+ export type Obj = { -+ a: number; -+ readonly foo: string; -+ }; -+ export declare const processedInternally1: { -+ readonly foo: string; -+ }; -+ export declare const processedInternally2: { -+ foo: string; -+ }; -+ -+==== other.d.ts (0 errors) ==== -+ type OmitReal = Pick>; -+ type OmitUnveiled = { -+ [P in Exclude]: T[P]; -+ }; -+ export declare function test1(obj: T, k: K): OmitReal; -+ export declare function test2(obj: T, k: K): OmitUnveiled; -+ export {}; -+ \ No newline at end of file + } \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/inlineMappedTypeModifierDeclarationEmit.types b/testdata/baselines/reference/submodule/compiler/inlineMappedTypeModifierDeclarationEmit.types index 6ad267b193..3b61ebf0ed 100644 --- a/testdata/baselines/reference/submodule/compiler/inlineMappedTypeModifierDeclarationEmit.types +++ b/testdata/baselines/reference/submodule/compiler/inlineMappedTypeModifierDeclarationEmit.types @@ -12,7 +12,7 @@ export function wrappedTest1(obj: T, k: K) { return test1(obj, k); >test1(obj, k) : Exclude extends infer T_1 extends keyof T ? { [P in T_1]: T[P]; } : never ->test1 : (obj: T_1, k: K_1) => Exclude extends infer T_2 extends keyof T_3 ? { [P in T_2]: T_3[P]; } : never +>test1 : (obj: T_1, k: K_1) => Exclude extends infer T_2 extends keyof T_1 ? { [P in T_2]: T_1[P]; } : never >obj : T >k : K } diff --git a/testdata/baselines/reference/submodule/compiler/inlineMappedTypeModifierDeclarationEmit.types.diff b/testdata/baselines/reference/submodule/compiler/inlineMappedTypeModifierDeclarationEmit.types.diff deleted file mode 100644 index 3396340857..0000000000 --- a/testdata/baselines/reference/submodule/compiler/inlineMappedTypeModifierDeclarationEmit.types.diff +++ /dev/null @@ -1,11 +0,0 @@ ---- old.inlineMappedTypeModifierDeclarationEmit.types -+++ new.inlineMappedTypeModifierDeclarationEmit.types -@@= skipped -11, +11 lines =@@ - - return test1(obj, k); - >test1(obj, k) : Exclude extends infer T_1 extends keyof T ? { [P in T_1]: T[P]; } : never -->test1 : (obj: T_1, k: K_1) => Exclude extends infer T_2 extends keyof T_1 ? { [P in T_2]: T_1[P]; } : never -+>test1 : (obj: T_1, k: K_1) => Exclude extends infer T_2 extends keyof T_3 ? { [P in T_2]: T_3[P]; } : never - >obj : T - >k : K - } \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/mappedTypeGenericInstantiationPreservesHomomorphism.js b/testdata/baselines/reference/submodule/compiler/mappedTypeGenericInstantiationPreservesHomomorphism.js index d7fb45fc72..5c29d48b49 100644 --- a/testdata/baselines/reference/submodule/compiler/mappedTypeGenericInstantiationPreservesHomomorphism.js +++ b/testdata/baselines/reference/submodule/compiler/mappedTypeGenericInstantiationPreservesHomomorphism.js @@ -29,4 +29,4 @@ type PrivateMapped = { }; export {}; //// [api.d.ts] -export declare const mappedUnionWithPrivateType: (...args: T) => T[any] extends infer T_1 extends unknown ? { [K in keyof T_1]: T[any][K]; } : never; +export declare const mappedUnionWithPrivateType: (...args: T) => T[any] extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never; diff --git a/testdata/baselines/reference/submodule/compiler/mappedTypeGenericInstantiationPreservesHomomorphism.js.diff b/testdata/baselines/reference/submodule/compiler/mappedTypeGenericInstantiationPreservesHomomorphism.js.diff index 5b9b7e6c6f..86079eedfc 100644 --- a/testdata/baselines/reference/submodule/compiler/mappedTypeGenericInstantiationPreservesHomomorphism.js.diff +++ b/testdata/baselines/reference/submodule/compiler/mappedTypeGenericInstantiationPreservesHomomorphism.js.diff @@ -8,10 +8,3 @@ +const internal_1 = require("./internal"); const mappedUnionWithPrivateType = (...args) => (0, internal_1.usePrivateType)(...args); exports.mappedUnionWithPrivateType = mappedUnionWithPrivateType; - -@@= skipped -12, +12 lines =@@ - }; - export {}; - //// [api.d.ts] --export declare const mappedUnionWithPrivateType: (...args: T) => T[any] extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never; -+export declare const mappedUnionWithPrivateType: (...args: T) => T[any] extends infer T_1 extends unknown ? { [K in keyof T_1]: T[any][K]; } : never; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/mappedTypeGenericInstantiationPreservesHomomorphism.types b/testdata/baselines/reference/submodule/compiler/mappedTypeGenericInstantiationPreservesHomomorphism.types index 51a3a89371..dda55bd4ba 100644 --- a/testdata/baselines/reference/submodule/compiler/mappedTypeGenericInstantiationPreservesHomomorphism.types +++ b/testdata/baselines/reference/submodule/compiler/mappedTypeGenericInstantiationPreservesHomomorphism.types @@ -10,14 +10,14 @@ type PrivateMapped = {[K in keyof Obj]: Obj[K]}; === api.ts === import {usePrivateType} from './internal'; ->usePrivateType : (...args: T) => T[any] extends infer T_1 extends unknown ? { [K in keyof T_1]: T[any][K]; } : never +>usePrivateType : (...args: T) => T[any] extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never export const mappedUnionWithPrivateType = (...args: T) => usePrivateType(...args); ->mappedUnionWithPrivateType : (...args: T) => T[any] extends infer T_1 extends unknown ? { [K in keyof T_1]: T[any][K]; } : never ->(...args: T) => usePrivateType(...args) : (...args: T) => T[any] extends infer T_1 extends unknown ? { [K in keyof T_1]: T[any][K]; } : never +>mappedUnionWithPrivateType : (...args: T) => T[any] extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never +>(...args: T) => usePrivateType(...args) : (...args: T) => T[any] extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never >args : T ->usePrivateType(...args) : T_1[any] extends infer T extends unknown ? { [K in keyof T]: T_1[any][K]; } : never ->usePrivateType : (...args: T_1) => T_3[any] extends infer T_2 extends unknown ? { [K in keyof T_2]: T_3[any][K]; } : never +>usePrivateType(...args) : T[any] extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never +>usePrivateType : (...args: T_1) => T_1[any] extends infer T_2 ? { [K in keyof T_2]: T_2[K]; } : never >...args : unknown >args : T diff --git a/testdata/baselines/reference/submodule/compiler/mappedTypeGenericInstantiationPreservesHomomorphism.types.diff b/testdata/baselines/reference/submodule/compiler/mappedTypeGenericInstantiationPreservesHomomorphism.types.diff deleted file mode 100644 index 0ad381275c..0000000000 --- a/testdata/baselines/reference/submodule/compiler/mappedTypeGenericInstantiationPreservesHomomorphism.types.diff +++ /dev/null @@ -1,21 +0,0 @@ ---- old.mappedTypeGenericInstantiationPreservesHomomorphism.types -+++ new.mappedTypeGenericInstantiationPreservesHomomorphism.types -@@= skipped -9, +9 lines =@@ - - === api.ts === - import {usePrivateType} from './internal'; -->usePrivateType : (...args: T) => T[any] extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never -+>usePrivateType : (...args: T) => T[any] extends infer T_1 extends unknown ? { [K in keyof T_1]: T[any][K]; } : never - - export const mappedUnionWithPrivateType = (...args: T) => usePrivateType(...args); -->mappedUnionWithPrivateType : (...args: T) => T[any] extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never -->(...args: T) => usePrivateType(...args) : (...args: T) => T[any] extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never -+>mappedUnionWithPrivateType : (...args: T) => T[any] extends infer T_1 extends unknown ? { [K in keyof T_1]: T[any][K]; } : never -+>(...args: T) => usePrivateType(...args) : (...args: T) => T[any] extends infer T_1 extends unknown ? { [K in keyof T_1]: T[any][K]; } : never - >args : T -->usePrivateType(...args) : T[any] extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never -->usePrivateType : (...args: T_1) => T_1[any] extends infer T_2 ? { [K in keyof T_2]: T_2[K]; } : never -+>usePrivateType(...args) : T_1[any] extends infer T extends unknown ? { [K in keyof T]: T_1[any][K]; } : never -+>usePrivateType : (...args: T_1) => T_3[any] extends infer T_2 extends unknown ? { [K in keyof T_2]: T_3[any][K]; } : never - >...args : unknown - >args : T diff --git a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter1.types b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter1.types index 67e047e445..78179c59dc 100644 --- a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter1.types +++ b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter1.types @@ -26,7 +26,7 @@ type Prettify = { [K in keyof T]: T[K] } & {}; >Prettify : { [K in keyof T]: T[K]; } type InferObjectType = Prettify< ->InferObjectType : { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? k : never]?: Shape[k]["output"] | undefined; } & { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? never : k]: Shape[k]["output"]; } extends infer T extends unknown ? { [K in keyof T]: ({ [k in keyof Shape as Shape[k] extends { optional: "true"; } ? k : never]?: Shape[k]["output"] | undefined; } & { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? never : k]: Shape[k]["output"]; })[K]; } : never +>InferObjectType : { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? k : never]?: Shape[k]["output"] | undefined; } & { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? never : k]: Shape[k]["output"]; } extends infer T ? { [K in keyof T]: T[K]; } : never { [k in keyof Shape as Shape[k] extends { optional: "true" } >optional : "true" @@ -46,7 +46,7 @@ interface ZodObject extends ZodType { >optional : "false" output: InferObjectType; ->output : { [k in keyof T as T[k] extends { optional: "true"; } ? k : never]?: T[k]["output"] | undefined; } & { [k in keyof T as T[k] extends { optional: "true"; } ? never : k]: T[k]["output"]; } extends infer T_1 extends unknown ? { [K in keyof T_1]: ({ [k in keyof T as T[k] extends { optional: "true"; } ? k : never]?: T[k]["output"] | undefined; } & { [k in keyof T as T[k] extends { optional: "true"; } ? never : k]: T[k]["output"]; })[K]; } : never +>output : { [k in keyof T as T[k] extends { optional: "true"; } ? k : never]?: T[k]["output"] | undefined; } & { [k in keyof T as T[k] extends { optional: "true"; } ? never : k]: T[k]["output"]; } extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never } interface ZodOptional extends ZodType { diff --git a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter1.types.diff b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter1.types.diff index a16f8426b8..8f1ab92e19 100644 --- a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter1.types.diff +++ b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter1.types.diff @@ -5,7 +5,7 @@ type InferObjectType = Prettify< ->InferObjectType : { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? k : never]?: Shape[k]["output"] | undefined; } & { [k_1 in keyof Shape as Shape[k_1] extends { optional: "true"; } ? never : k_1]: Shape[k_1]["output"]; } extends infer T ? { [K in keyof T]: T[K]; } : never -+>InferObjectType : { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? k : never]?: Shape[k]["output"] | undefined; } & { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? never : k]: Shape[k]["output"]; } extends infer T extends unknown ? { [K in keyof T]: ({ [k in keyof Shape as Shape[k] extends { optional: "true"; } ? k : never]?: Shape[k]["output"] | undefined; } & { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? never : k]: Shape[k]["output"]; })[K]; } : never ++>InferObjectType : { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? k : never]?: Shape[k]["output"] | undefined; } & { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? never : k]: Shape[k]["output"]; } extends infer T ? { [K in keyof T]: T[K]; } : never { [k in keyof Shape as Shape[k] extends { optional: "true" } >optional : "true" @@ -14,7 +14,7 @@ output: InferObjectType; ->output : { [k in keyof T as T[k] extends { optional: "true"; } ? k : never]?: T[k]["output"] | undefined; } & { [k_1 in keyof T as T[k_1] extends { optional: "true"; } ? never : k_1]: T[k_1]["output"]; } extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never -+>output : { [k in keyof T as T[k] extends { optional: "true"; } ? k : never]?: T[k]["output"] | undefined; } & { [k in keyof T as T[k] extends { optional: "true"; } ? never : k]: T[k]["output"]; } extends infer T_1 extends unknown ? { [K in keyof T_1]: ({ [k in keyof T as T[k] extends { optional: "true"; } ? k : never]?: T[k]["output"] | undefined; } & { [k in keyof T as T[k] extends { optional: "true"; } ? never : k]: T[k]["output"]; })[K]; } : never ++>output : { [k in keyof T as T[k] extends { optional: "true"; } ? k : never]?: T[k]["output"] | undefined; } & { [k in keyof T as T[k] extends { optional: "true"; } ? never : k]: T[k]["output"]; } extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never } interface ZodOptional extends ZodType { \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter2.types b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter2.types index 2349927427..8e326c2f2b 100644 --- a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter2.types +++ b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter2.types @@ -24,7 +24,7 @@ type Prettify = { [K in keyof T]: T[K] } & {}; >Prettify : { [K in keyof T]: T[K]; } type InferObjectType = Prettify< ->InferObjectType : { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? k : never]?: Shape[k]["output"] | undefined; } & { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? never : k]: Shape[k]["output"]; } extends infer T extends unknown ? { [K in keyof T]: ({ [k in keyof Shape as Shape[k] extends { optional: "true"; } ? k : never]?: Shape[k]["output"] | undefined; } & { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? never : k]: Shape[k]["output"]; })[K]; } : never +>InferObjectType : { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? k : never]?: Shape[k]["output"] | undefined; } & { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? never : k]: Shape[k]["output"]; } extends infer T ? { [K in keyof T]: T[K]; } : never { [k in keyof Shape as Shape[k] extends { optional: "true" } >optional : "true" @@ -44,7 +44,7 @@ interface ZodObject extends ZodType { >optional : "false" output: InferObjectType; ->output : { [k in keyof T as T[k] extends { optional: "true"; } ? k : never]?: T[k]["output"] | undefined; } & { [k in keyof T as T[k] extends { optional: "true"; } ? never : k]: T[k]["output"]; } extends infer T_1 extends unknown ? { [K in keyof T_1]: ({ [k in keyof T as T[k] extends { optional: "true"; } ? k : never]?: T[k]["output"] | undefined; } & { [k in keyof T as T[k] extends { optional: "true"; } ? never : k]: T[k]["output"]; })[K]; } : never +>output : { [k in keyof T as T[k] extends { optional: "true"; } ? k : never]?: T[k]["output"] | undefined; } & { [k in keyof T as T[k] extends { optional: "true"; } ? never : k]: T[k]["output"]; } extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never } interface ZodOptional extends ZodType { diff --git a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter2.types.diff b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter2.types.diff index ebf06f4579..460e4127c0 100644 --- a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter2.types.diff +++ b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter2.types.diff @@ -5,7 +5,7 @@ type InferObjectType = Prettify< ->InferObjectType : { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? k : never]?: Shape[k]["output"] | undefined; } & { [k_1 in keyof Shape as Shape[k_1] extends { optional: "true"; } ? never : k_1]: Shape[k_1]["output"]; } extends infer T ? { [K in keyof T]: T[K]; } : never -+>InferObjectType : { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? k : never]?: Shape[k]["output"] | undefined; } & { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? never : k]: Shape[k]["output"]; } extends infer T extends unknown ? { [K in keyof T]: ({ [k in keyof Shape as Shape[k] extends { optional: "true"; } ? k : never]?: Shape[k]["output"] | undefined; } & { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? never : k]: Shape[k]["output"]; })[K]; } : never ++>InferObjectType : { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? k : never]?: Shape[k]["output"] | undefined; } & { [k in keyof Shape as Shape[k] extends { optional: "true"; } ? never : k]: Shape[k]["output"]; } extends infer T ? { [K in keyof T]: T[K]; } : never { [k in keyof Shape as Shape[k] extends { optional: "true" } >optional : "true" @@ -14,7 +14,7 @@ output: InferObjectType; ->output : { [k in keyof T as T[k] extends { optional: "true"; } ? k : never]?: T[k]["output"] | undefined; } & { [k_1 in keyof T as T[k_1] extends { optional: "true"; } ? never : k_1]: T[k_1]["output"]; } extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never -+>output : { [k in keyof T as T[k] extends { optional: "true"; } ? k : never]?: T[k]["output"] | undefined; } & { [k in keyof T as T[k] extends { optional: "true"; } ? never : k]: T[k]["output"]; } extends infer T_1 extends unknown ? { [K in keyof T_1]: ({ [k in keyof T as T[k] extends { optional: "true"; } ? k : never]?: T[k]["output"] | undefined; } & { [k in keyof T as T[k] extends { optional: "true"; } ? never : k]: T[k]["output"]; })[K]; } : never ++>output : { [k in keyof T as T[k] extends { optional: "true"; } ? k : never]?: T[k]["output"] | undefined; } & { [k in keyof T as T[k] extends { optional: "true"; } ? never : k]: T[k]["output"]; } extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never } interface ZodOptional extends ZodType { \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter3.errors.txt b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter3.errors.txt deleted file mode 100644 index 3a8f1b9818..0000000000 --- a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter3.errors.txt +++ /dev/null @@ -1,16 +0,0 @@ -noCircularitySelfReferentialGetter3.ts(1,7): error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. -noCircularitySelfReferentialGetter3.ts(3,7): error TS7023: 'self' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. - - -==== noCircularitySelfReferentialGetter3.ts (2 errors) ==== - const a = { - ~ -!!! error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. - prop: 42, - get self() { - ~~~~ -!!! error TS7023: 'self' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. - return a; - }, - } satisfies { prop: number; self: any }; - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter3.errors.txt.diff b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter3.errors.txt.diff deleted file mode 100644 index 6d0d285175..0000000000 --- a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter3.errors.txt.diff +++ /dev/null @@ -1,20 +0,0 @@ ---- old.noCircularitySelfReferentialGetter3.errors.txt -+++ new.noCircularitySelfReferentialGetter3.errors.txt -@@= skipped -0, +0 lines =@@ -- -+noCircularitySelfReferentialGetter3.ts(1,7): error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. -+noCircularitySelfReferentialGetter3.ts(3,7): error TS7023: 'self' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. -+ -+ -+==== noCircularitySelfReferentialGetter3.ts (2 errors) ==== -+ const a = { -+ ~ -+!!! error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. -+ prop: 42, -+ get self() { -+ ~~~~ -+!!! error TS7023: 'self' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. -+ return a; -+ }, -+ } satisfies { prop: number; self: any }; -+ \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter3.types b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter3.types index 742cbe14d9..0caaac102f 100644 --- a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter3.types +++ b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter3.types @@ -2,19 +2,19 @@ === noCircularitySelfReferentialGetter3.ts === const a = { ->a : any ->{ prop: 42, get self() { return a; },} satisfies { prop: number; self: any } : { prop: number; readonly self: any; } ->{ prop: 42, get self() { return a; },} : { prop: number; readonly self: any; } +>a : { prop: number; readonly self: any; } +>{ prop: 42, get self() { return a; },} satisfies { prop: number; self: any } : { prop: number; readonly self: { prop: number; readonly self: any; }; } +>{ prop: 42, get self() { return a; },} : { prop: number; readonly self: { prop: number; readonly self: any; }; } prop: 42, >prop : number >42 : 42 get self() { ->self : any +>self : { prop: number; readonly self: any; } return a; ->a : any +>a : { prop: number; readonly self: any; } }, } satisfies { prop: number; self: any }; diff --git a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter3.types.diff b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter3.types.diff deleted file mode 100644 index 3de7e98b46..0000000000 --- a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter3.types.diff +++ /dev/null @@ -1,27 +0,0 @@ ---- old.noCircularitySelfReferentialGetter3.types -+++ new.noCircularitySelfReferentialGetter3.types -@@= skipped -1, +1 lines =@@ - - === noCircularitySelfReferentialGetter3.ts === - const a = { -->a : { prop: number; readonly self: any; } -->{ prop: 42, get self() { return a; },} satisfies { prop: number; self: any } : { prop: number; readonly self: { prop: number; readonly self: any; }; } -->{ prop: 42, get self() { return a; },} : { prop: number; readonly self: { prop: number; readonly self: any; }; } -+>a : any -+>{ prop: 42, get self() { return a; },} satisfies { prop: number; self: any } : { prop: number; readonly self: any; } -+>{ prop: 42, get self() { return a; },} : { prop: number; readonly self: any; } - - prop: 42, - >prop : number - >42 : 42 - - get self() { -->self : { prop: number; readonly self: any; } -+>self : any - - return a; -->a : { prop: number; readonly self: any; } -+>a : any - - }, - } satisfies { prop: number; self: any }; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.errors.txt b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.errors.txt deleted file mode 100644 index f0ab68fa87..0000000000 --- a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.errors.txt +++ /dev/null @@ -1,18 +0,0 @@ -noCircularitySelfReferentialGetter4.ts(1,7): error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. -noCircularitySelfReferentialGetter4.ts(3,7): error TS7023: 'self' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. - - -==== noCircularitySelfReferentialGetter4.ts (2 errors) ==== - const a = { - ~ -!!! error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. - prop: 42, - get self() { - ~~~~ -!!! error TS7023: 'self' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. - return a; - }, - } satisfies { prop: number; self: any }; - - const prop = a.self.self.self.self.self.prop; - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.errors.txt.diff b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.errors.txt.diff deleted file mode 100644 index 1116478d50..0000000000 --- a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.errors.txt.diff +++ /dev/null @@ -1,22 +0,0 @@ ---- old.noCircularitySelfReferentialGetter4.errors.txt -+++ new.noCircularitySelfReferentialGetter4.errors.txt -@@= skipped -0, +0 lines =@@ -- -+noCircularitySelfReferentialGetter4.ts(1,7): error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. -+noCircularitySelfReferentialGetter4.ts(3,7): error TS7023: 'self' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. -+ -+ -+==== noCircularitySelfReferentialGetter4.ts (2 errors) ==== -+ const a = { -+ ~ -+!!! error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. -+ prop: 42, -+ get self() { -+ ~~~~ -+!!! error TS7023: 'self' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. -+ return a; -+ }, -+ } satisfies { prop: number; self: any }; -+ -+ const prop = a.self.self.self.self.self.prop; -+ \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.symbols b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.symbols index c80d78dcef..92533c3a7f 100644 --- a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.symbols +++ b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.symbols @@ -20,5 +20,17 @@ const a = { const prop = a.self.self.self.self.self.prop; >prop : Symbol(prop, Decl(noCircularitySelfReferentialGetter4.ts, 7, 5)) +>a.self.self.self.self.self.prop : Symbol(prop, Decl(noCircularitySelfReferentialGetter4.ts, 0, 11)) +>a.self.self.self.self.self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) +>a.self.self.self.self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) +>a.self.self.self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) +>a.self.self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) +>a.self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) >a : Symbol(a, Decl(noCircularitySelfReferentialGetter4.ts, 0, 5)) +>self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) +>self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) +>self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) +>self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) +>self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) +>prop : Symbol(prop, Decl(noCircularitySelfReferentialGetter4.ts, 0, 11)) diff --git a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.symbols.diff b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.symbols.diff deleted file mode 100644 index a7092083ce..0000000000 --- a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.symbols.diff +++ /dev/null @@ -1,19 +0,0 @@ ---- old.noCircularitySelfReferentialGetter4.symbols -+++ new.noCircularitySelfReferentialGetter4.symbols -@@= skipped -19, +19 lines =@@ - - const prop = a.self.self.self.self.self.prop; - >prop : Symbol(prop, Decl(noCircularitySelfReferentialGetter4.ts, 7, 5)) -->a.self.self.self.self.self.prop : Symbol(prop, Decl(noCircularitySelfReferentialGetter4.ts, 0, 11)) -->a.self.self.self.self.self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) -->a.self.self.self.self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) -->a.self.self.self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) -->a.self.self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) -->a.self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) - >a : Symbol(a, Decl(noCircularitySelfReferentialGetter4.ts, 0, 5)) -->self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) -->self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) -->self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) -->self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) -->self : Symbol(self, Decl(noCircularitySelfReferentialGetter4.ts, 1, 11)) -->prop : Symbol(prop, Decl(noCircularitySelfReferentialGetter4.ts, 0, 11)) diff --git a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.types b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.types index a49b8f970a..ee88891c6a 100644 --- a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.types +++ b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.types @@ -2,19 +2,19 @@ === noCircularitySelfReferentialGetter4.ts === const a = { ->a : any ->{ prop: 42, get self() { return a; },} satisfies { prop: number; self: any } : { prop: number; readonly self: any; } ->{ prop: 42, get self() { return a; },} : { prop: number; readonly self: any; } +>a : { prop: number; readonly self: any; } +>{ prop: 42, get self() { return a; },} satisfies { prop: number; self: any } : { prop: number; readonly self: { prop: number; readonly self: any; }; } +>{ prop: 42, get self() { return a; },} : { prop: number; readonly self: { prop: number; readonly self: any; }; } prop: 42, >prop : number >42 : 42 get self() { ->self : any +>self : { prop: number; readonly self: any; } return a; ->a : any +>a : { prop: number; readonly self: any; } }, } satisfies { prop: number; self: any }; @@ -22,18 +22,18 @@ const a = { >self : any const prop = a.self.self.self.self.self.prop; ->prop : any ->a.self.self.self.self.self.prop : any ->a.self.self.self.self.self : any ->a.self.self.self.self : any ->a.self.self.self : any ->a.self.self : any ->a.self : any ->a : any ->self : any ->self : any ->self : any ->self : any ->self : any ->prop : any +>prop : number +>a.self.self.self.self.self.prop : number +>a.self.self.self.self.self : { prop: number; readonly self: any; } +>a.self.self.self.self : { prop: number; readonly self: any; } +>a.self.self.self : { prop: number; readonly self: any; } +>a.self.self : { prop: number; readonly self: any; } +>a.self : { prop: number; readonly self: any; } +>a : { prop: number; readonly self: any; } +>self : { prop: number; readonly self: any; } +>self : { prop: number; readonly self: any; } +>self : { prop: number; readonly self: any; } +>self : { prop: number; readonly self: any; } +>self : { prop: number; readonly self: any; } +>prop : number diff --git a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.types.diff b/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.types.diff deleted file mode 100644 index 6d42220ca3..0000000000 --- a/testdata/baselines/reference/submodule/compiler/noCircularitySelfReferentialGetter4.types.diff +++ /dev/null @@ -1,59 +0,0 @@ ---- old.noCircularitySelfReferentialGetter4.types -+++ new.noCircularitySelfReferentialGetter4.types -@@= skipped -1, +1 lines =@@ - - === noCircularitySelfReferentialGetter4.ts === - const a = { -->a : { prop: number; readonly self: any; } -->{ prop: 42, get self() { return a; },} satisfies { prop: number; self: any } : { prop: number; readonly self: { prop: number; readonly self: any; }; } -->{ prop: 42, get self() { return a; },} : { prop: number; readonly self: { prop: number; readonly self: any; }; } -+>a : any -+>{ prop: 42, get self() { return a; },} satisfies { prop: number; self: any } : { prop: number; readonly self: any; } -+>{ prop: 42, get self() { return a; },} : { prop: number; readonly self: any; } - - prop: 42, - >prop : number - >42 : 42 - - get self() { -->self : { prop: number; readonly self: any; } -+>self : any - - return a; -->a : { prop: number; readonly self: any; } -+>a : any - - }, - } satisfies { prop: number; self: any }; -@@= skipped -20, +20 lines =@@ - >self : any - - const prop = a.self.self.self.self.self.prop; -->prop : number -->a.self.self.self.self.self.prop : number -->a.self.self.self.self.self : { prop: number; readonly self: any; } -->a.self.self.self.self : { prop: number; readonly self: any; } -->a.self.self.self : { prop: number; readonly self: any; } -->a.self.self : { prop: number; readonly self: any; } -->a.self : { prop: number; readonly self: any; } -->a : { prop: number; readonly self: any; } -->self : { prop: number; readonly self: any; } -->self : { prop: number; readonly self: any; } -->self : { prop: number; readonly self: any; } -->self : { prop: number; readonly self: any; } -->self : { prop: number; readonly self: any; } -->prop : number -+>prop : any -+>a.self.self.self.self.self.prop : any -+>a.self.self.self.self.self : any -+>a.self.self.self.self : any -+>a.self.self.self : any -+>a.self.self : any -+>a.self : any -+>a : any -+>self : any -+>self : any -+>self : any -+>self : any -+>self : any -+>prop : any diff --git a/testdata/baselines/reference/submodule/compiler/predicateSemantics.errors.txt b/testdata/baselines/reference/submodule/compiler/predicateSemantics.errors.txt index 8b9b243bad..cf503611a4 100644 --- a/testdata/baselines/reference/submodule/compiler/predicateSemantics.errors.txt +++ b/testdata/baselines/reference/submodule/compiler/predicateSemantics.errors.txt @@ -6,15 +6,27 @@ predicateSemantics.ts(28,13): error TS2871: This expression is always nullish. predicateSemantics.ts(29,13): error TS2871: This expression is always nullish. predicateSemantics.ts(30,13): error TS2872: This kind of expression is always truthy. predicateSemantics.ts(31,13): error TS2872: This kind of expression is always truthy. -predicateSemantics.ts(32,13): error TS2870: This binary expression is never nullish. Are you missing parentheses? -predicateSemantics.ts(33,13): error TS2870: This binary expression is never nullish. Are you missing parentheses? -predicateSemantics.ts(34,13): error TS2870: This binary expression is never nullish. Are you missing parentheses? +predicateSemantics.ts(32,13): error TS2871: This expression is always nullish. +predicateSemantics.ts(32,21): error TS2871: This expression is always nullish. +predicateSemantics.ts(33,13): error TS2871: This expression is always nullish. +predicateSemantics.ts(34,13): error TS2871: This expression is always nullish. +predicateSemantics.ts(34,22): error TS2871: This expression is always nullish. +predicateSemantics.ts(36,20): error TS2871: This expression is always nullish. +predicateSemantics.ts(37,20): error TS2871: This expression is always nullish. predicateSemantics.ts(38,21): error TS2871: This expression is always nullish. predicateSemantics.ts(39,21): error TS2871: This expression is always nullish. -predicateSemantics.ts(40,21): error TS2870: This binary expression is never nullish. Are you missing parentheses? -predicateSemantics.ts(45,13): error TS2870: This binary expression is never nullish. Are you missing parentheses? -predicateSemantics.ts(46,13): error TS2870: This binary expression is never nullish. Are you missing parentheses? -predicateSemantics.ts(47,13): error TS2870: This binary expression is never nullish. Are you missing parentheses? +predicateSemantics.ts(40,21): error TS2871: This expression is always nullish. +predicateSemantics.ts(40,29): error TS2871: This expression is always nullish. +predicateSemantics.ts(41,21): error TS2871: This expression is always nullish. +predicateSemantics.ts(42,20): error TS2881: This expression is never nullish. +predicateSemantics.ts(43,21): error TS2881: This expression is never nullish. +predicateSemantics.ts(45,13): error TS2871: This expression is always nullish. +predicateSemantics.ts(45,21): error TS2871: This expression is always nullish. +predicateSemantics.ts(45,29): error TS2871: This expression is always nullish. +predicateSemantics.ts(46,13): error TS2871: This expression is always nullish. +predicateSemantics.ts(46,21): error TS2881: This expression is never nullish. +predicateSemantics.ts(47,13): error TS2871: This expression is always nullish. +predicateSemantics.ts(47,22): error TS2881: This expression is never nullish. predicateSemantics.ts(50,8): error TS2872: This kind of expression is always truthy. predicateSemantics.ts(51,11): error TS2872: This kind of expression is always truthy. predicateSemantics.ts(52,8): error TS2872: This kind of expression is always truthy. @@ -26,7 +38,7 @@ predicateSemantics.ts(89,1): error TS2869: Right operand of ?? is unreachable be predicateSemantics.ts(90,1): error TS2869: Right operand of ?? is unreachable because the left operand is never nullish. -==== predicateSemantics.ts (26 errors) ==== +==== predicateSemantics.ts (38 errors) ==== declare let opt: number | undefined; // OK: One or other operand is possibly nullish @@ -76,16 +88,24 @@ predicateSemantics.ts(90,1): error TS2869: Right operand of ?? is unreachable be !!! error TS2872: This kind of expression is always truthy. const p07 = null ?? null ?? null; ~~~~ -!!! error TS2870: This binary expression is never nullish. Are you missing parentheses? +!!! error TS2871: This expression is always nullish. + ~~~~ +!!! error TS2871: This expression is always nullish. const p08 = null ?? opt ?? null; ~~~~ -!!! error TS2870: This binary expression is never nullish. Are you missing parentheses? +!!! error TS2871: This expression is always nullish. const p09 = null ?? (opt ? null : undefined) ?? null; ~~~~ -!!! error TS2870: This binary expression is never nullish. Are you missing parentheses? +!!! error TS2871: This expression is always nullish. + ~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2871: This expression is always nullish. const p10 = opt ?? null ?? 1; + ~~~~ +!!! error TS2871: This expression is always nullish. const p11 = opt ?? null ?? null; + ~~~~ +!!! error TS2871: This expression is always nullish. const p12 = opt ?? (null ?? 1); ~~~~ !!! error TS2871: This expression is always nullish. @@ -94,20 +114,36 @@ predicateSemantics.ts(90,1): error TS2869: Right operand of ?? is unreachable be !!! error TS2871: This expression is always nullish. const p14 = opt ?? (null ?? null ?? null); ~~~~ -!!! error TS2870: This binary expression is never nullish. Are you missing parentheses? +!!! error TS2871: This expression is always nullish. + ~~~~ +!!! error TS2871: This expression is always nullish. const p15 = opt ?? (opt ? null : undefined) ?? null; + ~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2871: This expression is always nullish. const p16 = opt ?? 1 ?? 2; + ~ +!!! error TS2881: This expression is never nullish. const p17 = opt ?? (opt ? 1 : 2) ?? 3; + ~~~~~~~~~~~ +!!! error TS2881: This expression is never nullish. const p21 = null ?? null ?? null ?? null; ~~~~ -!!! error TS2870: This binary expression is never nullish. Are you missing parentheses? +!!! error TS2871: This expression is always nullish. + ~~~~ +!!! error TS2871: This expression is always nullish. + ~~~~ +!!! error TS2871: This expression is always nullish. const p22 = null ?? 1 ?? 1; ~~~~ -!!! error TS2870: This binary expression is never nullish. Are you missing parentheses? +!!! error TS2871: This expression is always nullish. + ~ +!!! error TS2881: This expression is never nullish. const p23 = null ?? (opt ? 1 : 2) ?? 1; ~~~~ -!!! error TS2870: This binary expression is never nullish. Are you missing parentheses? +!!! error TS2871: This expression is always nullish. + ~~~~~~~~~~~ +!!! error TS2881: This expression is never nullish. // Outer expression tests while ({} as any) { } diff --git a/testdata/baselines/reference/submodule/compiler/predicateSemantics.errors.txt.diff b/testdata/baselines/reference/submodule/compiler/predicateSemantics.errors.txt.diff deleted file mode 100644 index 5f593741f5..0000000000 --- a/testdata/baselines/reference/submodule/compiler/predicateSemantics.errors.txt.diff +++ /dev/null @@ -1,115 +0,0 @@ ---- old.predicateSemantics.errors.txt -+++ new.predicateSemantics.errors.txt -@@= skipped -5, +5 lines =@@ - predicateSemantics.ts(29,13): error TS2871: This expression is always nullish. - predicateSemantics.ts(30,13): error TS2872: This kind of expression is always truthy. - predicateSemantics.ts(31,13): error TS2872: This kind of expression is always truthy. --predicateSemantics.ts(32,13): error TS2871: This expression is always nullish. --predicateSemantics.ts(32,21): error TS2871: This expression is always nullish. --predicateSemantics.ts(33,13): error TS2871: This expression is always nullish. --predicateSemantics.ts(34,13): error TS2871: This expression is always nullish. --predicateSemantics.ts(34,22): error TS2871: This expression is always nullish. --predicateSemantics.ts(36,20): error TS2871: This expression is always nullish. --predicateSemantics.ts(37,20): error TS2871: This expression is always nullish. -+predicateSemantics.ts(32,13): error TS2870: This binary expression is never nullish. Are you missing parentheses? -+predicateSemantics.ts(33,13): error TS2870: This binary expression is never nullish. Are you missing parentheses? -+predicateSemantics.ts(34,13): error TS2870: This binary expression is never nullish. Are you missing parentheses? - predicateSemantics.ts(38,21): error TS2871: This expression is always nullish. - predicateSemantics.ts(39,21): error TS2871: This expression is always nullish. --predicateSemantics.ts(40,21): error TS2871: This expression is always nullish. --predicateSemantics.ts(40,29): error TS2871: This expression is always nullish. --predicateSemantics.ts(41,21): error TS2871: This expression is always nullish. --predicateSemantics.ts(42,20): error TS2881: This expression is never nullish. --predicateSemantics.ts(43,21): error TS2881: This expression is never nullish. --predicateSemantics.ts(45,13): error TS2871: This expression is always nullish. --predicateSemantics.ts(45,21): error TS2871: This expression is always nullish. --predicateSemantics.ts(45,29): error TS2871: This expression is always nullish. --predicateSemantics.ts(46,13): error TS2871: This expression is always nullish. --predicateSemantics.ts(46,21): error TS2881: This expression is never nullish. --predicateSemantics.ts(47,13): error TS2871: This expression is always nullish. --predicateSemantics.ts(47,22): error TS2881: This expression is never nullish. -+predicateSemantics.ts(40,21): error TS2870: This binary expression is never nullish. Are you missing parentheses? -+predicateSemantics.ts(45,13): error TS2870: This binary expression is never nullish. Are you missing parentheses? -+predicateSemantics.ts(46,13): error TS2870: This binary expression is never nullish. Are you missing parentheses? -+predicateSemantics.ts(47,13): error TS2870: This binary expression is never nullish. Are you missing parentheses? - predicateSemantics.ts(50,8): error TS2872: This kind of expression is always truthy. - predicateSemantics.ts(51,11): error TS2872: This kind of expression is always truthy. - predicateSemantics.ts(52,8): error TS2872: This kind of expression is always truthy. -@@= skipped -32, +20 lines =@@ - predicateSemantics.ts(90,1): error TS2869: Right operand of ?? is unreachable because the left operand is never nullish. - - --==== predicateSemantics.ts (38 errors) ==== -+==== predicateSemantics.ts (26 errors) ==== - declare let opt: number | undefined; - - // OK: One or other operand is possibly nullish -@@= skipped -50, +50 lines =@@ - !!! error TS2872: This kind of expression is always truthy. - const p07 = null ?? null ?? null; - ~~~~ --!!! error TS2871: This expression is always nullish. -- ~~~~ --!!! error TS2871: This expression is always nullish. -+!!! error TS2870: This binary expression is never nullish. Are you missing parentheses? - const p08 = null ?? opt ?? null; - ~~~~ --!!! error TS2871: This expression is always nullish. -+!!! error TS2870: This binary expression is never nullish. Are you missing parentheses? - const p09 = null ?? (opt ? null : undefined) ?? null; - ~~~~ --!!! error TS2871: This expression is always nullish. -- ~~~~~~~~~~~~~~~~~~~~~~ --!!! error TS2871: This expression is always nullish. -+!!! error TS2870: This binary expression is never nullish. Are you missing parentheses? - - const p10 = opt ?? null ?? 1; -- ~~~~ --!!! error TS2871: This expression is always nullish. - const p11 = opt ?? null ?? null; -- ~~~~ --!!! error TS2871: This expression is always nullish. - const p12 = opt ?? (null ?? 1); - ~~~~ - !!! error TS2871: This expression is always nullish. -@@= skipped -26, +18 lines =@@ - !!! error TS2871: This expression is always nullish. - const p14 = opt ?? (null ?? null ?? null); - ~~~~ --!!! error TS2871: This expression is always nullish. -- ~~~~ --!!! error TS2871: This expression is always nullish. -+!!! error TS2870: This binary expression is never nullish. Are you missing parentheses? - const p15 = opt ?? (opt ? null : undefined) ?? null; -- ~~~~~~~~~~~~~~~~~~~~~~ --!!! error TS2871: This expression is always nullish. - const p16 = opt ?? 1 ?? 2; -- ~ --!!! error TS2881: This expression is never nullish. - const p17 = opt ?? (opt ? 1 : 2) ?? 3; -- ~~~~~~~~~~~ --!!! error TS2881: This expression is never nullish. - - const p21 = null ?? null ?? null ?? null; - ~~~~ --!!! error TS2871: This expression is always nullish. -- ~~~~ --!!! error TS2871: This expression is always nullish. -- ~~~~ --!!! error TS2871: This expression is always nullish. -+!!! error TS2870: This binary expression is never nullish. Are you missing parentheses? - const p22 = null ?? 1 ?? 1; - ~~~~ --!!! error TS2871: This expression is always nullish. -- ~ --!!! error TS2881: This expression is never nullish. -+!!! error TS2870: This binary expression is never nullish. Are you missing parentheses? - const p23 = null ?? (opt ? 1 : 2) ?? 1; - ~~~~ --!!! error TS2871: This expression is always nullish. -- ~~~~~~~~~~~ --!!! error TS2881: This expression is never nullish. -+!!! error TS2870: This binary expression is never nullish. Are you missing parentheses? - - // Outer expression tests - while ({} as any) { } \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/promiseChaining.types b/testdata/baselines/reference/submodule/compiler/promiseChaining.types index 260556efd5..625bf487ea 100644 --- a/testdata/baselines/reference/submodule/compiler/promiseChaining.types +++ b/testdata/baselines/reference/submodule/compiler/promiseChaining.types @@ -26,7 +26,7 @@ class Chain { >this.then(x => result)/*S*/.then(x => "abc")/*string*/.then(x => x.length) : Chain >this.then(x => result)/*S*/.then(x => "abc")/*string*/.then : (cb: (x: string) => S) => Chain >this.then(x => result)/*S*/.then(x => "abc") : Chain ->this.then(x => result)/*S*/.then : (cb: (x: S) => S_1) => Chain +>this.then(x => result)/*S*/.then : (cb: (x: S_1) => S) => Chain >this.then(x => result) : Chain >this.then : (cb: (x: T) => S) => Chain >this : this @@ -34,7 +34,7 @@ class Chain { >x => result : (x: T) => S >x : T >result : S ->then : (cb: (x: S) => S_1) => Chain +>then : (cb: (x: S_1) => S) => Chain >x => "abc" : (x: S) => string >x : S >"abc" : "abc" diff --git a/testdata/baselines/reference/submodule/compiler/promiseChaining.types.diff b/testdata/baselines/reference/submodule/compiler/promiseChaining.types.diff deleted file mode 100644 index a91df9f8b1..0000000000 --- a/testdata/baselines/reference/submodule/compiler/promiseChaining.types.diff +++ /dev/null @@ -1,20 +0,0 @@ ---- old.promiseChaining.types -+++ new.promiseChaining.types -@@= skipped -25, +25 lines =@@ - >this.then(x => result)/*S*/.then(x => "abc")/*string*/.then(x => x.length) : Chain - >this.then(x => result)/*S*/.then(x => "abc")/*string*/.then : (cb: (x: string) => S) => Chain - >this.then(x => result)/*S*/.then(x => "abc") : Chain -->this.then(x => result)/*S*/.then : (cb: (x: S_1) => S) => Chain -+>this.then(x => result)/*S*/.then : (cb: (x: S) => S_1) => Chain - >this.then(x => result) : Chain - >this.then : (cb: (x: T) => S) => Chain - >this : this -@@= skipped -8, +8 lines =@@ - >x => result : (x: T) => S - >x : T - >result : S -->then : (cb: (x: S_1) => S) => Chain -+>then : (cb: (x: S) => S_1) => Chain - >x => "abc" : (x: S) => string - >x : S - >"abc" : "abc" \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/promiseChaining1.types b/testdata/baselines/reference/submodule/compiler/promiseChaining1.types index fc46235840..035742be3d 100644 --- a/testdata/baselines/reference/submodule/compiler/promiseChaining1.types +++ b/testdata/baselines/reference/submodule/compiler/promiseChaining1.types @@ -28,7 +28,7 @@ class Chain2 { >this.then(x => result)/*S*/.then(x => "abc")/*Function*/.then(x => x.length) : Chain2 >this.then(x => result)/*S*/.then(x => "abc")/*Function*/.then : (cb: (x: Function) => S) => Chain2 >this.then(x => result)/*S*/.then(x => "abc") : Chain2 ->this.then(x => result)/*S*/.then : (cb: (x: S) => S_1) => Chain2 +>this.then(x => result)/*S*/.then : (cb: (x: S_1) => S) => Chain2 >this.then(x => result) : Chain2 >this.then : (cb: (x: T) => S) => Chain2 >this : this @@ -36,7 +36,7 @@ class Chain2 { >x => result : (x: T) => S >x : T >result : S ->then : (cb: (x: S) => S_1) => Chain2 +>then : (cb: (x: S_1) => S) => Chain2 >x => "abc" : (x: S) => string >x : S >"abc" : "abc" diff --git a/testdata/baselines/reference/submodule/compiler/promiseChaining1.types.diff b/testdata/baselines/reference/submodule/compiler/promiseChaining1.types.diff deleted file mode 100644 index 350afe106a..0000000000 --- a/testdata/baselines/reference/submodule/compiler/promiseChaining1.types.diff +++ /dev/null @@ -1,20 +0,0 @@ ---- old.promiseChaining1.types -+++ new.promiseChaining1.types -@@= skipped -27, +27 lines =@@ - >this.then(x => result)/*S*/.then(x => "abc")/*Function*/.then(x => x.length) : Chain2 - >this.then(x => result)/*S*/.then(x => "abc")/*Function*/.then : (cb: (x: Function) => S) => Chain2 - >this.then(x => result)/*S*/.then(x => "abc") : Chain2 -->this.then(x => result)/*S*/.then : (cb: (x: S_1) => S) => Chain2 -+>this.then(x => result)/*S*/.then : (cb: (x: S) => S_1) => Chain2 - >this.then(x => result) : Chain2 - >this.then : (cb: (x: T) => S) => Chain2 - >this : this -@@= skipped -8, +8 lines =@@ - >x => result : (x: T) => S - >x : T - >result : S -->then : (cb: (x: S_1) => S) => Chain2 -+>then : (cb: (x: S) => S_1) => Chain2 - >x => "abc" : (x: S) => string - >x : S - >"abc" : "abc" \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/promiseChaining2.types b/testdata/baselines/reference/submodule/compiler/promiseChaining2.types index 665fbf4f7a..55d2d6dad3 100644 --- a/testdata/baselines/reference/submodule/compiler/promiseChaining2.types +++ b/testdata/baselines/reference/submodule/compiler/promiseChaining2.types @@ -28,7 +28,7 @@ class Chain2 { >this.then(x => result).then(x => "abc").then(x => x.length) : Chain2 >this.then(x => result).then(x => "abc").then : (cb: (x: Function) => S) => Chain2 >this.then(x => result).then(x => "abc") : Chain2 ->this.then(x => result).then : (cb: (x: S) => S_1) => Chain2 +>this.then(x => result).then : (cb: (x: S_1) => S) => Chain2 >this.then(x => result) : Chain2 >this.then : (cb: (x: T) => S) => Chain2 >this : this @@ -36,7 +36,7 @@ class Chain2 { >x => result : (x: T) => S >x : T >result : S ->then : (cb: (x: S) => S_1) => Chain2 +>then : (cb: (x: S_1) => S) => Chain2 >x => "abc" : (x: S) => string >x : S >"abc" : "abc" diff --git a/testdata/baselines/reference/submodule/compiler/promiseChaining2.types.diff b/testdata/baselines/reference/submodule/compiler/promiseChaining2.types.diff deleted file mode 100644 index f81db8759b..0000000000 --- a/testdata/baselines/reference/submodule/compiler/promiseChaining2.types.diff +++ /dev/null @@ -1,20 +0,0 @@ ---- old.promiseChaining2.types -+++ new.promiseChaining2.types -@@= skipped -27, +27 lines =@@ - >this.then(x => result).then(x => "abc").then(x => x.length) : Chain2 - >this.then(x => result).then(x => "abc").then : (cb: (x: Function) => S) => Chain2 - >this.then(x => result).then(x => "abc") : Chain2 -->this.then(x => result).then : (cb: (x: S_1) => S) => Chain2 -+>this.then(x => result).then : (cb: (x: S) => S_1) => Chain2 - >this.then(x => result) : Chain2 - >this.then : (cb: (x: T) => S) => Chain2 - >this : this -@@= skipped -8, +8 lines =@@ - >x => result : (x: T) => S - >x : T - >result : S -->then : (cb: (x: S_1) => S) => Chain2 -+>then : (cb: (x: S) => S_1) => Chain2 - >x => "abc" : (x: S) => string - >x : S - >"abc" : "abc" \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/compiler/recursiveConditionalCrash3.types b/testdata/baselines/reference/submodule/compiler/recursiveConditionalCrash3.types index ca8d8c7ece..4158cf1d80 100644 --- a/testdata/baselines/reference/submodule/compiler/recursiveConditionalCrash3.types +++ b/testdata/baselines/reference/submodule/compiler/recursiveConditionalCrash3.types @@ -175,10 +175,10 @@ let y2: Expand */ type UseQueryOptions > = Expand ->UseQueryOptions : T extends CanBeExpanded ? T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_2 ? T_2 extends T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_2 extends CanBeExpanded ? T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_3 ? T_3 extends T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_3 extends CanBeExpanded ? T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_1]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: any; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_3 extends (infer U)[] ? any[] : T_3 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? any : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: any; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: any; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_3 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_1]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: any; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? any : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: any; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never : T extends (infer U)[] ? any[] : T extends object ? { [K_1 in keyof T]-?: T[K_1] extends infer T_1 ? T_1 extends T[K_1] ? T_1 extends CanBeExpanded ? T_1[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_3 ? T_3 extends T_1[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_3 extends CanBeExpanded ? T_3[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_3[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_1]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: any; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_3 extends (infer U)[] ? any[] : T_3 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? any : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: any; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_3 : never : never : T_1 extends (infer U)[] ? any[] : T_1 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_1]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? any : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_1 : never : never; } : T +>UseQueryOptions : T extends CanBeExpanded ? T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_2 ? T_2 extends T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_2 extends CanBeExpanded ? T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_3 ? T_3 extends T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_3 extends CanBeExpanded ? T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_11]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_10]-?: T_10[K_1] extends infer T_12 ? T_12 extends T_10[K_1] ? T_12 extends CanBeExpanded ? any : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: any; } : T_12 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_9]-?: T_9[K_1] extends infer T_12 ? T_12 extends T_9[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? any : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: any; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_15 ? T_15 extends T_12[K_2] ? T_15 extends CanBeExpanded ? any : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_3 in keyof T_15]-?: any; } : T_15 : never : never; } : T_12 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_8]-?: T_8[K_1] extends infer T_12 ? T_12 extends T_8[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? any : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: any; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_16 ? T_16 extends T_14[K_2] ? T_16 extends CanBeExpanded ? any : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_3 in keyof T_16]-?: any; } : T_16 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_16 ? T_16 extends T_12[K_2] ? T_16 extends CanBeExpanded ? T_16[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_17 ? T_17 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_17 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_16[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_17 ? T_17 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_17 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? any : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: any; } : T_18 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_3 in keyof T_16]-?: T_16[K_3] extends infer T_19 ? T_19 extends T_16[K_3] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_4 in keyof T_19]-?: T_19[K_4] extends infer T_20 ? T_20 extends T_19[K_4] ? T_20 extends CanBeExpanded ? T_20["default"] : T_20 : never : never; } : T_19 : never : never; } : T_16 : never : never; } : T_12 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_7]-?: T_7[K_1] extends infer T_12 ? T_12 extends T_7[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? any : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: any; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_17 ? T_17 extends T_15[K_2] ? T_17 extends CanBeExpanded ? any : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_3 in keyof T_17]-?: any; } : T_17 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_17 ? T_17 extends T_14[K_2] ? T_17 extends CanBeExpanded ? T_17[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_17[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: any; } : T_19 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_3 in keyof T_17]-?: T_17[K_3] extends infer T_20 ? T_20 extends T_17[K_3] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_4 in keyof T_20]-?: T_20[K_4] extends infer T_21 ? T_21 extends T_20[K_4] ? T_21 extends CanBeExpanded ? T_21["default"] : T_21 : never : never; } : T_20 : never : never; } : T_17 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_17 ? T_17 extends T_12[K_2] ? T_17 extends CanBeExpanded ? T_17[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_17[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: any; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_21 ? T_21 extends T_19[K_3] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_4 in keyof T_21]-?: T_21[K_4] extends infer T_22 ? T_22 extends T_21[K_4] ? T_22 extends CanBeExpanded ? T_22["default"] : T_22 : never : never; } : T_21 : never : never; } : T_19 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_3 in keyof T_17]-?: T_17[K_3] extends infer T_21 ? T_21 extends T_17[K_3] ? T_21 extends CanBeExpanded ? T_21[PrefixWith, K_3, "."> extends infer T_22 ? T_22 extends PrefixWith, K_3, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith, K_3, "."> extends infer T_22 ? T_22 extends PrefixWith, K_3, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_24 ? T_24 extends T_23[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_4 in keyof T_21]-?: T_21[K_4] extends infer T_24 ? T_24 extends T_21[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_21 : never : never; } : T_17 : never : never; } : T_12 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_6]-?: T_6[K_1] extends infer T_12 ? T_12 extends T_6[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? any : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: any; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_18 ? T_18 extends T_16[K_2] ? T_18 extends CanBeExpanded ? any : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: any; } : T_18 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_18 ? T_18 extends T_15[K_2] ? T_18 extends CanBeExpanded ? T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: any; } : T_20 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: T_18[K_3] extends infer T_21 ? T_21 extends T_18[K_3] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_4 in keyof T_21]-?: T_21[K_4] extends infer T_22 ? T_22 extends T_21[K_4] ? T_22 extends CanBeExpanded ? T_22["default"] : T_22 : never : never; } : T_21 : never : never; } : T_18 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_18 ? T_18 extends T_14[K_2] ? T_18 extends CanBeExpanded ? T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: any; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_22 ? T_22 extends T_20[K_3] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_4 in keyof T_22]-?: T_22[K_4] extends infer T_23 ? T_23 extends T_22[K_4] ? T_23 extends CanBeExpanded ? T_23["default"] : T_23 : never : never; } : T_22 : never : never; } : T_20 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: T_18[K_3] extends infer T_22 ? T_22 extends T_18[K_3] ? T_22 extends CanBeExpanded ? T_22[PrefixWith, K_3, "."> extends infer T_23 ? T_23 extends PrefixWith, K_3, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith, K_3, "."> extends infer T_23 ? T_23 extends PrefixWith, K_3, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_25 ? T_25 extends T_24[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_4 in keyof T_22]-?: T_22[K_4] extends infer T_25 ? T_25 extends T_22[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_22 : never : never; } : T_18 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_18 ? T_18 extends T_12[K_2] ? T_18 extends CanBeExpanded ? T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: any; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_23 ? T_23 extends T_21[K_3] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_24 ? T_24 extends T_23[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_23 ? T_23 extends T_20[K_3] ? T_23 extends CanBeExpanded ? T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_26 ? T_26 extends T_23[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_23 : never : never; } : T_20 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: T_18[K_3] extends infer T_23 ? T_23 extends T_18[K_3] ? T_23 extends CanBeExpanded ? T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_27 ? T_27 extends T_25[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_27 ? T_27 extends T_23[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_23 : never : never; } : T_18 : never : never; } : T_12 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_5]-?: T_5[K_1] extends infer T_12 ? T_12 extends T_5[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? any : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: any; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_19 ? T_19 extends T_17[K_2] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: any; } : T_19 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_19 ? T_19 extends T_16[K_2] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: any; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_22 ? T_22 extends T_19[K_3] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_4 in keyof T_22]-?: T_22[K_4] extends infer T_23 ? T_23 extends T_22[K_4] ? T_23 extends CanBeExpanded ? T_23["default"] : T_23 : never : never; } : T_22 : never : never; } : T_19 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_19 ? T_19 extends T_15[K_2] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: any; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_23 ? T_23 extends T_21[K_3] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_24 ? T_24 extends T_23[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_23 ? T_23 extends T_19[K_3] ? T_23 extends CanBeExpanded ? T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_26 ? T_26 extends T_23[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_23 : never : never; } : T_19 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_19 ? T_19 extends T_14[K_2] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: any; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_24 ? T_24 extends T_22[K_3] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_25 ? T_25 extends T_24[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_24 ? T_24 extends T_21[K_3] ? T_24 extends CanBeExpanded ? T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_27 ? T_27 extends T_24[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_24 : never : never; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_24 ? T_24 extends T_19[K_3] ? T_24 extends CanBeExpanded ? T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_28 ? T_28 extends T_26[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_26 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_28 ? T_28 extends T_24[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_24 : never : never; } : T_19 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_19 ? T_19 extends T_12[K_2] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: any; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_25 ? T_25 extends T_23[K_3] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_25 ? T_25 extends T_22[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_28 ? T_28 extends T_25[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_25 : never : never; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_25 ? T_25 extends T_21[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_29 ? T_29 extends T_27[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_29 ? T_29 extends T_25[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_25 : never : never; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_25 ? T_25 extends T_19[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_30 ? T_30 extends T_28[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_30 ? T_30 extends T_25[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_25 : never : never; } : T_19 : never : never; } : T_12 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_4]-?: T_4[K_1] extends infer T_12 ? T_12 extends T_4[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_2 in keyof T_19]-?: any; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: T_18[K_2] extends infer T_20 ? T_20 extends T_18[K_2] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: any; } : T_20 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_20 ? T_20 extends T_17[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: any; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_23 ? T_23 extends T_20[K_3] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_24 ? T_24 extends T_23[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never; } : T_20 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_20 ? T_20 extends T_16[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: any; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_24 ? T_24 extends T_22[K_3] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_25 ? T_25 extends T_24[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_24 ? T_24 extends T_20[K_3] ? T_24 extends CanBeExpanded ? T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_27 ? T_27 extends T_24[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_24 : never : never; } : T_20 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_20 ? T_20 extends T_15[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: any; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_25 ? T_25 extends T_23[K_3] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_25 ? T_25 extends T_22[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_28 ? T_28 extends T_25[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_25 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_25 ? T_25 extends T_20[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_29 ? T_29 extends T_27[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_29 ? T_29 extends T_25[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_25 : never : never; } : T_20 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_20 ? T_20 extends T_14[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: any; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_26 ? T_26 extends T_24[K_3] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_26 ? T_26 extends T_23[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_29 ? T_29 extends T_26[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_26 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_26 ? T_26 extends T_22[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_30 ? T_30 extends T_28[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_30 ? T_30 extends T_26[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_26 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_26 ? T_26 extends T_20[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_31 ? T_31 extends T_29[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_31 ? T_31 extends T_28[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_31 ? T_31 extends T_26[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_26 : never : never; } : T_20 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_20 ? T_20 extends T_12[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_27 ? T_27 extends T_25[K_3] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_27 ? T_27 extends T_24[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_27 ? T_27 extends T_23[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_31 ? T_31 extends T_29[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_31 ? T_31 extends T_27[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_27 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_27 ? T_27 extends T_22[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_32 ? T_32 extends T_27[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_27 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_27 ? T_27 extends T_20[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_33 ? T_33 extends T_29[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_33 ? T_33 extends T_27[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_27 : never : never; } : T_20 : never : never; } : T_12 : never : never; } : T_4 : never : never : T_3 extends (infer U)[] ? any[] : T_3 extends object ? { [K_1 in keyof T_3]-?: T_3[K_1] extends infer T_12 ? T_12 extends T_3[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_2 in keyof T_20]-?: any; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_2 in keyof T_19]-?: T_19[K_2] extends infer T_21 ? T_21 extends T_19[K_2] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: any; } : T_21 : never : never; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: T_18[K_2] extends infer T_21 ? T_21 extends T_18[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: any; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_24 ? T_24 extends T_21[K_3] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_25 ? T_25 extends T_24[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never; } : T_21 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_21 ? T_21 extends T_17[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: any; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_25 ? T_25 extends T_23[K_3] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_25 ? T_25 extends T_21[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_28 ? T_28 extends T_25[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_25 : never : never; } : T_21 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_21 ? T_21 extends T_16[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: any; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_26 ? T_26 extends T_24[K_3] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_26 ? T_26 extends T_23[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_29 ? T_29 extends T_26[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_26 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_26 ? T_26 extends T_21[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_30 ? T_30 extends T_28[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_30 ? T_30 extends T_26[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_26 : never : never; } : T_21 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_21 ? T_21 extends T_15[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_27 ? T_27 extends T_25[K_3] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_27 ? T_27 extends T_24[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_27 ? T_27 extends T_23[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_31 ? T_31 extends T_29[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_31 ? T_31 extends T_27[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_27 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_27 ? T_27 extends T_21[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_32 ? T_32 extends T_27[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_27 : never : never; } : T_21 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_21 ? T_21 extends T_14[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: any; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_28 ? T_28 extends T_26[K_3] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_28 ? T_28 extends T_25[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_31 ? T_31 extends T_28[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_28 ? T_28 extends T_24[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_32 ? T_32 extends T_28[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_28 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_28 ? T_28 extends T_23[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_33 ? T_33 extends T_28[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_28 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_28 ? T_28 extends T_21[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_34 ? T_34 extends T_30[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_34 ? T_34 extends T_28[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_28 : never : never; } : T_21 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_21 ? T_21 extends T_12[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: any; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_29 ? T_29 extends T_27[K_3] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_29 ? T_29 extends T_26[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_29 ? T_29 extends T_25[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_33 ? T_33 extends T_29[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_29 ? T_29 extends T_24[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_34 ? T_34 extends T_29[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_29 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_29 ? T_29 extends T_23[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_35 ? T_35 extends T_31[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_35 ? T_35 extends T_29[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_29 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_29 ? T_29 extends T_21[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_36 ? T_36 extends T_32[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_36 ? T_36 extends T_31[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_36 ? T_36 extends T_29[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_29 : never : never; } : T_21 : never : never; } : T_12 : never : never; } : T_3 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_2]-?: T_2[K_1] extends infer T_12 ? T_12 extends T_2[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_2 in keyof T_21]-?: any; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_2 in keyof T_20]-?: T_20[K_2] extends infer T_22 ? T_22 extends T_20[K_2] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: any; } : T_22 : never : never; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_2 in keyof T_19]-?: T_19[K_2] extends infer T_22 ? T_22 extends T_19[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: any; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_25 ? T_25 extends T_22[K_3] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_22 : never : never; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: T_18[K_2] extends infer T_22 ? T_22 extends T_18[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: any; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_26 ? T_26 extends T_24[K_3] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_26 ? T_26 extends T_22[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_29 ? T_29 extends T_26[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_26 : never : never; } : T_22 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_22 ? T_22 extends T_17[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_27 ? T_27 extends T_25[K_3] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_27 ? T_27 extends T_24[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_27 ? T_27 extends T_22[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_31 ? T_31 extends T_29[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_31 ? T_31 extends T_27[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_27 : never : never; } : T_22 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_22 ? T_22 extends T_16[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: any; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_28 ? T_28 extends T_26[K_3] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_28 ? T_28 extends T_25[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_31 ? T_31 extends T_28[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_28 ? T_28 extends T_24[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_32 ? T_32 extends T_28[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_28 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_28 ? T_28 extends T_22[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_33 ? T_33 extends T_28[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_28 : never : never; } : T_22 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_22 ? T_22 extends T_15[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: any; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_29 ? T_29 extends T_27[K_3] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_29 ? T_29 extends T_26[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_29 ? T_29 extends T_25[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_33 ? T_33 extends T_29[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_29 ? T_29 extends T_24[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_34 ? T_34 extends T_29[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_29 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_29 ? T_29 extends T_22[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_35 ? T_35 extends T_31[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_35 ? T_35 extends T_29[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_29 : never : never; } : T_22 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_22 ? T_22 extends T_14[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: any; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_30 ? T_30 extends T_28[K_3] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_30 ? T_30 extends T_27[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_30 ? T_30 extends T_26[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_34 ? T_34 extends T_30[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_30 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_30 ? T_30 extends T_25[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_35 ? T_35 extends T_30[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_30 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_30 ? T_30 extends T_24[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_36 ? T_36 extends T_32[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_36 ? T_36 extends T_30[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_30 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_30 ? T_30 extends T_22[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_37 ? T_37 extends T_34[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_37 ? T_37 extends T_33[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_37 ? T_37 extends T_32[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_37 ? T_37 extends T_30[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_30 : never : never; } : T_22 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_22 ? T_22 extends T_12[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_3 in keyof T_30]-?: any; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: T_29[K_3] extends infer T_31 ? T_31 extends T_29[K_3] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_31 ? T_31 extends T_28[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_31 ? T_31 extends T_27[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_35 ? T_35 extends T_31[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_31 ? T_31 extends T_26[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_36 ? T_36 extends T_31[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_31 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_31 ? T_31 extends T_25[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_37 ? T_37 extends T_34[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_37 ? T_37 extends T_33[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_37 ? T_37 extends T_31[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_31 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_31 ? T_31 extends T_24[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_38 ? T_38 extends T_37[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_38 ? T_38 extends T_36[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_38 ? T_38 extends T_35[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_38 ? T_38 extends T_34[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_38 ? T_38 extends T_33[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_38 ? T_38 extends T_31[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_31 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_31 ? T_31 extends T_22[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? any : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_39 ? T_39 extends T_38[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_39 ? T_39 extends T_37[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_39 ? T_39 extends T_36[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_39 ? T_39 extends T_35[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_39 ? T_39 extends T_34[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_39 ? T_39 extends T_33[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_39 ? T_39 extends T_31[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_31 : never : never; } : T_22 : never : never; } : T_12 : never : never; } : T_2 : never : never : T extends (infer U)[] ? any[] : T extends object ? { [K_1 in keyof T]-?: T[K_1] extends infer T_12 ? T_12 extends T[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_2 in keyof T_22]-?: any; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_2 in keyof T_21]-?: T_21[K_2] extends infer T_23 ? T_23 extends T_21[K_2] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: any; } : T_23 : never : never; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_2 in keyof T_20]-?: T_20[K_2] extends infer T_23 ? T_23 extends T_20[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: any; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_26 ? T_26 extends T_23[K_3] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_23 : never : never; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_2 in keyof T_19]-?: T_19[K_2] extends infer T_23 ? T_23 extends T_19[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_27 ? T_27 extends T_25[K_3] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_27 ? T_27 extends T_23[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_23 : never : never; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: T_18[K_2] extends infer T_23 ? T_23 extends T_18[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: any; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_28 ? T_28 extends T_26[K_3] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_28 ? T_28 extends T_25[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_31 ? T_31 extends T_28[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_28 ? T_28 extends T_23[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_32 ? T_32 extends T_28[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_28 : never : never; } : T_23 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_23 ? T_23 extends T_17[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: any; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_29 ? T_29 extends T_27[K_3] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_29 ? T_29 extends T_26[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_29 ? T_29 extends T_25[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_33 ? T_33 extends T_29[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_29 ? T_29 extends T_23[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_34 ? T_34 extends T_29[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_29 : never : never; } : T_23 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_23 ? T_23 extends T_16[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: any; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_30 ? T_30 extends T_28[K_3] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_30 ? T_30 extends T_27[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_30 ? T_30 extends T_26[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_34 ? T_34 extends T_30[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_30 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_30 ? T_30 extends T_25[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_35 ? T_35 extends T_30[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_30 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_30 ? T_30 extends T_23[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_36 ? T_36 extends T_32[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_36 ? T_36 extends T_30[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_30 : never : never; } : T_23 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_23 ? T_23 extends T_15[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_3 in keyof T_30]-?: any; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: T_29[K_3] extends infer T_31 ? T_31 extends T_29[K_3] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_31 ? T_31 extends T_28[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_31 ? T_31 extends T_27[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_35 ? T_35 extends T_31[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_31 ? T_31 extends T_26[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_36 ? T_36 extends T_31[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_31 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_31 ? T_31 extends T_25[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_37 ? T_37 extends T_34[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_37 ? T_37 extends T_33[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_37 ? T_37 extends T_31[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_31 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_31 ? T_31 extends T_23[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_38 ? T_38 extends T_37[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_38 ? T_38 extends T_36[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_38 ? T_38 extends T_35[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_38 ? T_38 extends T_34[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_38 ? T_38 extends T_33[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_38 ? T_38 extends T_31[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_31 : never : never; } : T_23 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_23 ? T_23 extends T_14[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_3 in keyof T_31]-?: any; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_3 in keyof T_30]-?: T_30[K_3] extends infer T_32 ? T_32 extends T_30[K_3] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: T_29[K_3] extends infer T_32 ? T_32 extends T_29[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_32 ? T_32 extends T_28[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_36 ? T_36 extends T_32[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_32 ? T_32 extends T_27[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_37 ? T_37 extends T_34[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_37 ? T_37 extends T_32[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_32 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_32 ? T_32 extends T_26[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_38 ? T_38 extends T_37[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_38 ? T_38 extends T_36[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_38 ? T_38 extends T_35[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_38 ? T_38 extends T_34[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_38 ? T_38 extends T_32[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_32 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_32 ? T_32 extends T_25[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? any : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_39 ? T_39 extends T_38[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_39 ? T_39 extends T_37[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_39 ? T_39 extends T_36[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_39 ? T_39 extends T_35[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_39 ? T_39 extends T_34[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_39 ? T_39 extends T_32[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_32 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_32 ? T_32 extends T_23[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? any : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_4 in keyof T_39]-?: T_39[K_4] extends infer T_40 ? T_40 extends T_39[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_40 ? T_40 extends T_38[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_40 ? T_40 extends T_37[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_40 ? T_40 extends T_36[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_40 ? T_40 extends T_35[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_40 ? T_40 extends T_34[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_40 ? T_40 extends T_32[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_32 : never : never; } : T_23 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_23 ? T_23 extends T_12[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_3 in keyof T_32]-?: any; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_3 in keyof T_31]-?: T_31[K_3] extends infer T_33 ? T_33 extends T_31[K_3] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_3 in keyof T_30]-?: T_30[K_3] extends infer T_33 ? T_33 extends T_30[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: T_29[K_3] extends infer T_33 ? T_33 extends T_29[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_37 ? T_37 extends T_33[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_33 ? T_33 extends T_28[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_38 ? T_38 extends T_37[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_38 ? T_38 extends T_36[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_38 ? T_38 extends T_35[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_38 ? T_38 extends T_33[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_33 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_33 ? T_33 extends T_27[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? any : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_39 ? T_39 extends T_38[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_39 ? T_39 extends T_37[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_39 ? T_39 extends T_36[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_39 ? T_39 extends T_35[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_39 ? T_39 extends T_33[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_33 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_33 ? T_33 extends T_26[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? any : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_4 in keyof T_39]-?: T_39[K_4] extends infer T_40 ? T_40 extends T_39[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_40 ? T_40 extends T_38[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_40 ? T_40 extends T_37[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_40 ? T_40 extends T_36[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_40 ? T_40 extends T_35[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_40 ? T_40 extends T_33[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_33 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_33 ? T_33 extends T_25[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? T_39[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_40 ? T_40 extends T_39[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_40 extends CanBeExpanded ? any : T_40 extends (infer U)[] ? any[] : T_40 extends object ? { [K_4 in keyof T_40]-?: T_40[K_4] extends infer T_41 ? T_41 extends T_40[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_40 : never : never : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_4 in keyof T_39]-?: T_39[K_4] extends infer T_41 ? T_41 extends T_39[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_41 ? T_41 extends T_38[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_41 ? T_41 extends T_37[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_41 ? T_41 extends T_36[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_41 ? T_41 extends T_35[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_41 ? T_41 extends T_33[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_33 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_33 ? T_33 extends T_23[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? T_39[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_40 ? T_40 extends T_39[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_40 extends CanBeExpanded ? T_40[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_41 ? T_41 extends T_40[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_41 extends CanBeExpanded ? any : T_41 extends (infer U)[] ? any[] : T_41 extends object ? { [K_4 in keyof T_41]-?: T_41[K_4] extends infer T_42 ? T_42 extends T_41[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_41 : never : never : T_40 extends (infer U)[] ? any[] : T_40 extends object ? { [K_4 in keyof T_40]-?: T_40[K_4] extends infer T_42 ? T_42 extends T_40[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_40 : never : never : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_4 in keyof T_39]-?: T_39[K_4] extends infer T_42 ? T_42 extends T_39[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_42 ? T_42 extends T_38[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_42 ? T_42 extends T_37[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_42 ? T_42 extends T_36[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_42 ? T_42 extends T_35[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_42 ? T_42 extends T_33[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_33 : never : never; } : T_23 : never : never; } : T_12 : never : never; } : T type UseQueryOptions2 = Expand_ ->UseQueryOptions2 : T extends CanBeExpanded ? T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_2 ? T_2 extends T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_2 extends CanBeExpanded ? T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_3 ? T_3 extends T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_3 extends CanBeExpanded ? T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_1]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: any; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_3 extends (infer U)[] ? any[] : T_3 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? any : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: any; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: any; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_3 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_1]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: any; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? any : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: any; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never : T extends (infer U)[] ? any[] : T extends object ? { [K_1 in keyof T]-?: T[K_1] extends infer T_1 ? T_1 extends T[K_1] ? T_1 extends CanBeExpanded ? T_1[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_3 ? T_3 extends T_1[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_3 extends CanBeExpanded ? T_3[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_3[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_1]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: any; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_3 extends (infer U)[] ? any[] : T_3 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? any : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: any; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_3 : never : never : T_1 extends (infer U)[] ? any[] : T_1 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_1]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? any : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_1 : never : never; } : T +>UseQueryOptions2 : T extends CanBeExpanded ? T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_2 ? T_2 extends T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_2 extends CanBeExpanded ? T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_3 ? T_3 extends T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_3 extends CanBeExpanded ? T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_11]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_10]-?: T_10[K_1] extends infer T_12 ? T_12 extends T_10[K_1] ? T_12 extends CanBeExpanded ? any : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: any; } : T_12 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_9]-?: T_9[K_1] extends infer T_12 ? T_12 extends T_9[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? any : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: any; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_15 ? T_15 extends T_12[K_2] ? T_15 extends CanBeExpanded ? any : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_3 in keyof T_15]-?: any; } : T_15 : never : never; } : T_12 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_8]-?: T_8[K_1] extends infer T_12 ? T_12 extends T_8[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? any : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: any; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_16 ? T_16 extends T_14[K_2] ? T_16 extends CanBeExpanded ? any : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_3 in keyof T_16]-?: any; } : T_16 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_16 ? T_16 extends T_12[K_2] ? T_16 extends CanBeExpanded ? T_16[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_17 ? T_17 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_17 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_16[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_17 ? T_17 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_17 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? any : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: any; } : T_18 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_3 in keyof T_16]-?: T_16[K_3] extends infer T_19 ? T_19 extends T_16[K_3] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_4 in keyof T_19]-?: T_19[K_4] extends infer T_20 ? T_20 extends T_19[K_4] ? T_20 extends CanBeExpanded ? T_20["default"] : T_20 : never : never; } : T_19 : never : never; } : T_16 : never : never; } : T_12 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_7]-?: T_7[K_1] extends infer T_12 ? T_12 extends T_7[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? any : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: any; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_17 ? T_17 extends T_15[K_2] ? T_17 extends CanBeExpanded ? any : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_3 in keyof T_17]-?: any; } : T_17 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_17 ? T_17 extends T_14[K_2] ? T_17 extends CanBeExpanded ? T_17[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_17[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: any; } : T_19 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_3 in keyof T_17]-?: T_17[K_3] extends infer T_20 ? T_20 extends T_17[K_3] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_4 in keyof T_20]-?: T_20[K_4] extends infer T_21 ? T_21 extends T_20[K_4] ? T_21 extends CanBeExpanded ? T_21["default"] : T_21 : never : never; } : T_20 : never : never; } : T_17 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_17 ? T_17 extends T_12[K_2] ? T_17 extends CanBeExpanded ? T_17[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_17[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: any; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_21 ? T_21 extends T_19[K_3] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_4 in keyof T_21]-?: T_21[K_4] extends infer T_22 ? T_22 extends T_21[K_4] ? T_22 extends CanBeExpanded ? T_22["default"] : T_22 : never : never; } : T_21 : never : never; } : T_19 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_3 in keyof T_17]-?: T_17[K_3] extends infer T_21 ? T_21 extends T_17[K_3] ? T_21 extends CanBeExpanded ? T_21[PrefixWith, K_3, "."> extends infer T_22 ? T_22 extends PrefixWith, K_3, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith, K_3, "."> extends infer T_22 ? T_22 extends PrefixWith, K_3, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_24 ? T_24 extends T_23[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_4 in keyof T_21]-?: T_21[K_4] extends infer T_24 ? T_24 extends T_21[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_21 : never : never; } : T_17 : never : never; } : T_12 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_6]-?: T_6[K_1] extends infer T_12 ? T_12 extends T_6[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? any : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: any; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_18 ? T_18 extends T_16[K_2] ? T_18 extends CanBeExpanded ? any : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: any; } : T_18 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_18 ? T_18 extends T_15[K_2] ? T_18 extends CanBeExpanded ? T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: any; } : T_20 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: T_18[K_3] extends infer T_21 ? T_21 extends T_18[K_3] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_4 in keyof T_21]-?: T_21[K_4] extends infer T_22 ? T_22 extends T_21[K_4] ? T_22 extends CanBeExpanded ? T_22["default"] : T_22 : never : never; } : T_21 : never : never; } : T_18 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_18 ? T_18 extends T_14[K_2] ? T_18 extends CanBeExpanded ? T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: any; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_22 ? T_22 extends T_20[K_3] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_4 in keyof T_22]-?: T_22[K_4] extends infer T_23 ? T_23 extends T_22[K_4] ? T_23 extends CanBeExpanded ? T_23["default"] : T_23 : never : never; } : T_22 : never : never; } : T_20 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: T_18[K_3] extends infer T_22 ? T_22 extends T_18[K_3] ? T_22 extends CanBeExpanded ? T_22[PrefixWith, K_3, "."> extends infer T_23 ? T_23 extends PrefixWith, K_3, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith, K_3, "."> extends infer T_23 ? T_23 extends PrefixWith, K_3, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_25 ? T_25 extends T_24[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_4 in keyof T_22]-?: T_22[K_4] extends infer T_25 ? T_25 extends T_22[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_22 : never : never; } : T_18 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_18 ? T_18 extends T_12[K_2] ? T_18 extends CanBeExpanded ? T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: any; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_23 ? T_23 extends T_21[K_3] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_24 ? T_24 extends T_23[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_23 ? T_23 extends T_20[K_3] ? T_23 extends CanBeExpanded ? T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_26 ? T_26 extends T_23[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_23 : never : never; } : T_20 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: T_18[K_3] extends infer T_23 ? T_23 extends T_18[K_3] ? T_23 extends CanBeExpanded ? T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_27 ? T_27 extends T_25[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_27 ? T_27 extends T_23[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_23 : never : never; } : T_18 : never : never; } : T_12 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_5]-?: T_5[K_1] extends infer T_12 ? T_12 extends T_5[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? any : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: any; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_19 ? T_19 extends T_17[K_2] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: any; } : T_19 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_19 ? T_19 extends T_16[K_2] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: any; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_22 ? T_22 extends T_19[K_3] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_4 in keyof T_22]-?: T_22[K_4] extends infer T_23 ? T_23 extends T_22[K_4] ? T_23 extends CanBeExpanded ? T_23["default"] : T_23 : never : never; } : T_22 : never : never; } : T_19 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_19 ? T_19 extends T_15[K_2] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: any; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_23 ? T_23 extends T_21[K_3] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_24 ? T_24 extends T_23[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_23 ? T_23 extends T_19[K_3] ? T_23 extends CanBeExpanded ? T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_26 ? T_26 extends T_23[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_23 : never : never; } : T_19 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_19 ? T_19 extends T_14[K_2] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: any; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_24 ? T_24 extends T_22[K_3] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_25 ? T_25 extends T_24[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_24 ? T_24 extends T_21[K_3] ? T_24 extends CanBeExpanded ? T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_27 ? T_27 extends T_24[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_24 : never : never; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_24 ? T_24 extends T_19[K_3] ? T_24 extends CanBeExpanded ? T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_28 ? T_28 extends T_26[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_26 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_28 ? T_28 extends T_24[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_24 : never : never; } : T_19 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_19 ? T_19 extends T_12[K_2] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: any; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_25 ? T_25 extends T_23[K_3] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_25 ? T_25 extends T_22[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_28 ? T_28 extends T_25[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_25 : never : never; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_25 ? T_25 extends T_21[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_29 ? T_29 extends T_27[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_29 ? T_29 extends T_25[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_25 : never : never; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_25 ? T_25 extends T_19[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_30 ? T_30 extends T_28[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_30 ? T_30 extends T_25[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_25 : never : never; } : T_19 : never : never; } : T_12 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_4]-?: T_4[K_1] extends infer T_12 ? T_12 extends T_4[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_2 in keyof T_19]-?: any; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: T_18[K_2] extends infer T_20 ? T_20 extends T_18[K_2] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: any; } : T_20 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_20 ? T_20 extends T_17[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: any; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_23 ? T_23 extends T_20[K_3] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_24 ? T_24 extends T_23[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never; } : T_20 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_20 ? T_20 extends T_16[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: any; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_24 ? T_24 extends T_22[K_3] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_25 ? T_25 extends T_24[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_24 ? T_24 extends T_20[K_3] ? T_24 extends CanBeExpanded ? T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_27 ? T_27 extends T_24[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_24 : never : never; } : T_20 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_20 ? T_20 extends T_15[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: any; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_25 ? T_25 extends T_23[K_3] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_25 ? T_25 extends T_22[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_28 ? T_28 extends T_25[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_25 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_25 ? T_25 extends T_20[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_29 ? T_29 extends T_27[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_29 ? T_29 extends T_25[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_25 : never : never; } : T_20 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_20 ? T_20 extends T_14[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: any; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_26 ? T_26 extends T_24[K_3] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_26 ? T_26 extends T_23[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_29 ? T_29 extends T_26[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_26 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_26 ? T_26 extends T_22[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_30 ? T_30 extends T_28[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_30 ? T_30 extends T_26[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_26 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_26 ? T_26 extends T_20[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_31 ? T_31 extends T_29[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_31 ? T_31 extends T_28[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_31 ? T_31 extends T_26[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_26 : never : never; } : T_20 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_20 ? T_20 extends T_12[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_27 ? T_27 extends T_25[K_3] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_27 ? T_27 extends T_24[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_27 ? T_27 extends T_23[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_31 ? T_31 extends T_29[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_31 ? T_31 extends T_27[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_27 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_27 ? T_27 extends T_22[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_32 ? T_32 extends T_27[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_27 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_27 ? T_27 extends T_20[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_33 ? T_33 extends T_29[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_33 ? T_33 extends T_27[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_27 : never : never; } : T_20 : never : never; } : T_12 : never : never; } : T_4 : never : never : T_3 extends (infer U)[] ? any[] : T_3 extends object ? { [K_1 in keyof T_3]-?: T_3[K_1] extends infer T_12 ? T_12 extends T_3[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_2 in keyof T_20]-?: any; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_2 in keyof T_19]-?: T_19[K_2] extends infer T_21 ? T_21 extends T_19[K_2] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: any; } : T_21 : never : never; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: T_18[K_2] extends infer T_21 ? T_21 extends T_18[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: any; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_24 ? T_24 extends T_21[K_3] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_25 ? T_25 extends T_24[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never; } : T_21 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_21 ? T_21 extends T_17[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: any; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_25 ? T_25 extends T_23[K_3] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_25 ? T_25 extends T_21[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_28 ? T_28 extends T_25[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_25 : never : never; } : T_21 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_21 ? T_21 extends T_16[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: any; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_26 ? T_26 extends T_24[K_3] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_26 ? T_26 extends T_23[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_29 ? T_29 extends T_26[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_26 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_26 ? T_26 extends T_21[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_30 ? T_30 extends T_28[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_30 ? T_30 extends T_26[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_26 : never : never; } : T_21 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_21 ? T_21 extends T_15[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_27 ? T_27 extends T_25[K_3] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_27 ? T_27 extends T_24[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_27 ? T_27 extends T_23[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_31 ? T_31 extends T_29[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_31 ? T_31 extends T_27[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_27 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_27 ? T_27 extends T_21[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_32 ? T_32 extends T_27[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_27 : never : never; } : T_21 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_21 ? T_21 extends T_14[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: any; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_28 ? T_28 extends T_26[K_3] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_28 ? T_28 extends T_25[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_31 ? T_31 extends T_28[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_28 ? T_28 extends T_24[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_32 ? T_32 extends T_28[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_28 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_28 ? T_28 extends T_23[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_33 ? T_33 extends T_28[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_28 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_28 ? T_28 extends T_21[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_34 ? T_34 extends T_30[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_34 ? T_34 extends T_28[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_28 : never : never; } : T_21 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_21 ? T_21 extends T_12[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: any; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_29 ? T_29 extends T_27[K_3] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_29 ? T_29 extends T_26[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_29 ? T_29 extends T_25[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_33 ? T_33 extends T_29[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_29 ? T_29 extends T_24[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_34 ? T_34 extends T_29[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_29 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_29 ? T_29 extends T_23[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_35 ? T_35 extends T_31[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_35 ? T_35 extends T_29[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_29 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_29 ? T_29 extends T_21[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_36 ? T_36 extends T_32[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_36 ? T_36 extends T_31[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_36 ? T_36 extends T_29[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_29 : never : never; } : T_21 : never : never; } : T_12 : never : never; } : T_3 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_2]-?: T_2[K_1] extends infer T_12 ? T_12 extends T_2[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_2 in keyof T_21]-?: any; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_2 in keyof T_20]-?: T_20[K_2] extends infer T_22 ? T_22 extends T_20[K_2] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: any; } : T_22 : never : never; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_2 in keyof T_19]-?: T_19[K_2] extends infer T_22 ? T_22 extends T_19[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: any; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_25 ? T_25 extends T_22[K_3] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_22 : never : never; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: T_18[K_2] extends infer T_22 ? T_22 extends T_18[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: any; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_26 ? T_26 extends T_24[K_3] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_26 ? T_26 extends T_22[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_29 ? T_29 extends T_26[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_26 : never : never; } : T_22 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_22 ? T_22 extends T_17[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_27 ? T_27 extends T_25[K_3] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_27 ? T_27 extends T_24[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_27 ? T_27 extends T_22[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_31 ? T_31 extends T_29[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_31 ? T_31 extends T_27[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_27 : never : never; } : T_22 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_22 ? T_22 extends T_16[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: any; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_28 ? T_28 extends T_26[K_3] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_28 ? T_28 extends T_25[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_31 ? T_31 extends T_28[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_28 ? T_28 extends T_24[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_32 ? T_32 extends T_28[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_28 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_28 ? T_28 extends T_22[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_33 ? T_33 extends T_28[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_28 : never : never; } : T_22 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_22 ? T_22 extends T_15[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: any; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_29 ? T_29 extends T_27[K_3] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_29 ? T_29 extends T_26[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_29 ? T_29 extends T_25[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_33 ? T_33 extends T_29[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_29 ? T_29 extends T_24[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_34 ? T_34 extends T_29[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_29 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_29 ? T_29 extends T_22[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_35 ? T_35 extends T_31[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_35 ? T_35 extends T_29[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_29 : never : never; } : T_22 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_22 ? T_22 extends T_14[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: any; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_30 ? T_30 extends T_28[K_3] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_30 ? T_30 extends T_27[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_30 ? T_30 extends T_26[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_34 ? T_34 extends T_30[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_30 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_30 ? T_30 extends T_25[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_35 ? T_35 extends T_30[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_30 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_30 ? T_30 extends T_24[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_36 ? T_36 extends T_32[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_36 ? T_36 extends T_30[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_30 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_30 ? T_30 extends T_22[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_37 ? T_37 extends T_34[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_37 ? T_37 extends T_33[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_37 ? T_37 extends T_32[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_37 ? T_37 extends T_30[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_30 : never : never; } : T_22 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_22 ? T_22 extends T_12[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_3 in keyof T_30]-?: any; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: T_29[K_3] extends infer T_31 ? T_31 extends T_29[K_3] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_31 ? T_31 extends T_28[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_31 ? T_31 extends T_27[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_35 ? T_35 extends T_31[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_31 ? T_31 extends T_26[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_36 ? T_36 extends T_31[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_31 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_31 ? T_31 extends T_25[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_37 ? T_37 extends T_34[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_37 ? T_37 extends T_33[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_37 ? T_37 extends T_31[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_31 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_31 ? T_31 extends T_24[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_38 ? T_38 extends T_37[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_38 ? T_38 extends T_36[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_38 ? T_38 extends T_35[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_38 ? T_38 extends T_34[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_38 ? T_38 extends T_33[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_38 ? T_38 extends T_31[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_31 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_31 ? T_31 extends T_22[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? any : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_39 ? T_39 extends T_38[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_39 ? T_39 extends T_37[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_39 ? T_39 extends T_36[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_39 ? T_39 extends T_35[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_39 ? T_39 extends T_34[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_39 ? T_39 extends T_33[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_39 ? T_39 extends T_31[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_31 : never : never; } : T_22 : never : never; } : T_12 : never : never; } : T_2 : never : never : T extends (infer U)[] ? any[] : T extends object ? { [K_1 in keyof T]-?: T[K_1] extends infer T_12 ? T_12 extends T[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_2 in keyof T_22]-?: any; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_2 in keyof T_21]-?: T_21[K_2] extends infer T_23 ? T_23 extends T_21[K_2] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: any; } : T_23 : never : never; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_2 in keyof T_20]-?: T_20[K_2] extends infer T_23 ? T_23 extends T_20[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: any; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_26 ? T_26 extends T_23[K_3] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_23 : never : never; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_2 in keyof T_19]-?: T_19[K_2] extends infer T_23 ? T_23 extends T_19[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_27 ? T_27 extends T_25[K_3] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_27 ? T_27 extends T_23[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_23 : never : never; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: T_18[K_2] extends infer T_23 ? T_23 extends T_18[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: any; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_28 ? T_28 extends T_26[K_3] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_28 ? T_28 extends T_25[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_31 ? T_31 extends T_28[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_28 ? T_28 extends T_23[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_32 ? T_32 extends T_28[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_28 : never : never; } : T_23 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_23 ? T_23 extends T_17[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: any; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_29 ? T_29 extends T_27[K_3] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_29 ? T_29 extends T_26[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_29 ? T_29 extends T_25[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_33 ? T_33 extends T_29[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_29 ? T_29 extends T_23[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_34 ? T_34 extends T_29[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_29 : never : never; } : T_23 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_23 ? T_23 extends T_16[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: any; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_30 ? T_30 extends T_28[K_3] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_30 ? T_30 extends T_27[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_30 ? T_30 extends T_26[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_34 ? T_34 extends T_30[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_30 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_30 ? T_30 extends T_25[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_35 ? T_35 extends T_30[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_30 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_30 ? T_30 extends T_23[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_36 ? T_36 extends T_32[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_36 ? T_36 extends T_30[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_30 : never : never; } : T_23 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_23 ? T_23 extends T_15[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_3 in keyof T_30]-?: any; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: T_29[K_3] extends infer T_31 ? T_31 extends T_29[K_3] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_31 ? T_31 extends T_28[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_31 ? T_31 extends T_27[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_35 ? T_35 extends T_31[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_31 ? T_31 extends T_26[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_36 ? T_36 extends T_31[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_31 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_31 ? T_31 extends T_25[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_37 ? T_37 extends T_34[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_37 ? T_37 extends T_33[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_37 ? T_37 extends T_31[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_31 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_31 ? T_31 extends T_23[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_38 ? T_38 extends T_37[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_38 ? T_38 extends T_36[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_38 ? T_38 extends T_35[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_38 ? T_38 extends T_34[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_38 ? T_38 extends T_33[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_38 ? T_38 extends T_31[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_31 : never : never; } : T_23 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_23 ? T_23 extends T_14[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_3 in keyof T_31]-?: any; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_3 in keyof T_30]-?: T_30[K_3] extends infer T_32 ? T_32 extends T_30[K_3] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: T_29[K_3] extends infer T_32 ? T_32 extends T_29[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_32 ? T_32 extends T_28[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_36 ? T_36 extends T_32[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_32 ? T_32 extends T_27[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_37 ? T_37 extends T_34[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_37 ? T_37 extends T_32[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_32 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_32 ? T_32 extends T_26[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_38 ? T_38 extends T_37[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_38 ? T_38 extends T_36[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_38 ? T_38 extends T_35[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_38 ? T_38 extends T_34[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_38 ? T_38 extends T_32[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_32 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_32 ? T_32 extends T_25[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? any : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_39 ? T_39 extends T_38[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_39 ? T_39 extends T_37[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_39 ? T_39 extends T_36[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_39 ? T_39 extends T_35[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_39 ? T_39 extends T_34[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_39 ? T_39 extends T_32[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_32 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_32 ? T_32 extends T_23[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? any : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_4 in keyof T_39]-?: T_39[K_4] extends infer T_40 ? T_40 extends T_39[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_40 ? T_40 extends T_38[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_40 ? T_40 extends T_37[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_40 ? T_40 extends T_36[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_40 ? T_40 extends T_35[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_40 ? T_40 extends T_34[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_40 ? T_40 extends T_32[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_32 : never : never; } : T_23 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_23 ? T_23 extends T_12[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_3 in keyof T_32]-?: any; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_3 in keyof T_31]-?: T_31[K_3] extends infer T_33 ? T_33 extends T_31[K_3] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_3 in keyof T_30]-?: T_30[K_3] extends infer T_33 ? T_33 extends T_30[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: T_29[K_3] extends infer T_33 ? T_33 extends T_29[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_37 ? T_37 extends T_33[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_33 ? T_33 extends T_28[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_38 ? T_38 extends T_37[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_38 ? T_38 extends T_36[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_38 ? T_38 extends T_35[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_38 ? T_38 extends T_33[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_33 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_33 ? T_33 extends T_27[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? any : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_39 ? T_39 extends T_38[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_39 ? T_39 extends T_37[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_39 ? T_39 extends T_36[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_39 ? T_39 extends T_35[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_39 ? T_39 extends T_33[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_33 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_33 ? T_33 extends T_26[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? any : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_4 in keyof T_39]-?: T_39[K_4] extends infer T_40 ? T_40 extends T_39[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_40 ? T_40 extends T_38[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_40 ? T_40 extends T_37[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_40 ? T_40 extends T_36[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_40 ? T_40 extends T_35[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_40 ? T_40 extends T_33[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_33 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_33 ? T_33 extends T_25[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? T_39[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_40 ? T_40 extends T_39[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_40 extends CanBeExpanded ? any : T_40 extends (infer U)[] ? any[] : T_40 extends object ? { [K_4 in keyof T_40]-?: T_40[K_4] extends infer T_41 ? T_41 extends T_40[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_40 : never : never : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_4 in keyof T_39]-?: T_39[K_4] extends infer T_41 ? T_41 extends T_39[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_41 ? T_41 extends T_38[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_41 ? T_41 extends T_37[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_41 ? T_41 extends T_36[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_41 ? T_41 extends T_35[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_41 ? T_41 extends T_33[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_33 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_33 ? T_33 extends T_23[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? T_39[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_40 ? T_40 extends T_39[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_40 extends CanBeExpanded ? T_40[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_41 ? T_41 extends T_40[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_41 extends CanBeExpanded ? any : T_41 extends (infer U)[] ? any[] : T_41 extends object ? { [K_4 in keyof T_41]-?: T_41[K_4] extends infer T_42 ? T_42 extends T_41[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_41 : never : never : T_40 extends (infer U)[] ? any[] : T_40 extends object ? { [K_4 in keyof T_40]-?: T_40[K_4] extends infer T_42 ? T_42 extends T_40[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_40 : never : never : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_4 in keyof T_39]-?: T_39[K_4] extends infer T_42 ? T_42 extends T_39[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_42 ? T_42 extends T_38[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_42 ? T_42 extends T_37[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_42 ? T_42 extends T_36[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_42 ? T_42 extends T_35[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_42 ? T_42 extends T_33[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_33 : never : never; } : T_23 : never : never; } : T_12 : never : never; } : T type UseQueryOptions3 = Expand_ extends infer O ? O : never >UseQueryOptions3 : UseQueryOptions3 diff --git a/testdata/baselines/reference/submodule/compiler/recursiveConditionalCrash3.types.diff b/testdata/baselines/reference/submodule/compiler/recursiveConditionalCrash3.types.diff index 7596ae2cc3..dff8e8138b 100644 --- a/testdata/baselines/reference/submodule/compiler/recursiveConditionalCrash3.types.diff +++ b/testdata/baselines/reference/submodule/compiler/recursiveConditionalCrash3.types.diff @@ -5,11 +5,11 @@ type UseQueryOptions > = Expand ->UseQueryOptions : T extends CanBeExpanded ? T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_2 ? T_2 extends T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_2 extends CanBeExpanded ? T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_3 ? T_3 extends T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_3 extends CanBeExpanded ? T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_11]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_2 in keyof T_10]-?: T_10[K_2] extends infer T_12 ? T_12 extends T_10[K_2] ? T_12 extends CanBeExpanded ? any : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_4 in keyof T_12]-?: any; } : T_12 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_3 in keyof T_9]-?: T_9[K_3] extends infer T_12 ? T_12 extends T_9[K_3] ? T_12 extends CanBeExpanded ? T_12[`${string & K_3}` extends infer T_13 ? T_13 extends `${string & K_3}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_3}` extends infer T_13 ? T_13 extends `${string & K_3}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? any : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_5 in keyof T_14]-?: any; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_6 in keyof T_12]-?: T_12[K_6] extends infer T_15 ? T_15 extends T_12[K_6] ? T_15 extends CanBeExpanded ? any : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_7 in keyof T_15]-?: any; } : T_15 : never : never; } : T_12 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_4 in keyof T_8]-?: T_8[K_4] extends infer T_12 ? T_12 extends T_8[K_4] ? T_12 extends CanBeExpanded ? T_12[`${string & K_4}` extends infer T_13 ? T_13 extends `${string & K_4}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_4}` extends infer T_13 ? T_13 extends `${string & K_4}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_4}` extends infer T_13 ? T_13 extends `${string & K_4}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_4}` extends infer T_13 ? T_13 extends `${string & K_4}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? any : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_6 in keyof T_15]-?: any; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_7 in keyof T_14]-?: T_14[K_7] extends infer T_16 ? T_16 extends T_14[K_7] ? T_16 extends CanBeExpanded ? any : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_8 in keyof T_16]-?: any; } : T_16 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_8 in keyof T_12]-?: T_12[K_8] extends infer T_16 ? T_16 extends T_12[K_8] ? T_16 extends CanBeExpanded ? T_16[PrefixWith<`${string & K_4}`, K_8, "."> extends infer T_17 ? T_17 extends PrefixWith<`${string & K_4}`, K_8, "."> ? T_17 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_16[PrefixWith<`${string & K_4}`, K_8, "."> extends infer T_17 ? T_17 extends PrefixWith<`${string & K_4}`, K_8, "."> ? T_17 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? any : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_9 in keyof T_18]-?: any; } : T_18 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_10 in keyof T_16]-?: T_16[K_10] extends infer T_19 ? T_19 extends T_16[K_10] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_11 in keyof T_19]-?: T_19[K_11] extends infer T_20 ? T_20 extends T_19[K_11] ? T_20 extends CanBeExpanded ? T_20["default"] : T_20 : never : never; } : T_19 : never : never; } : T_16 : never : never; } : T_12 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_5 in keyof T_7]-?: T_7[K_5] extends infer T_12 ? T_12 extends T_7[K_5] ? T_12 extends CanBeExpanded ? T_12[`${string & K_5}` extends infer T_13 ? T_13 extends `${string & K_5}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_5}` extends infer T_13 ? T_13 extends `${string & K_5}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_5}` extends infer T_13 ? T_13 extends `${string & K_5}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_5}` extends infer T_13 ? T_13 extends `${string & K_5}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_5}` extends infer T_13 ? T_13 extends `${string & K_5}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_5}` extends infer T_13 ? T_13 extends `${string & K_5}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? any : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_7 in keyof T_16]-?: any; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_8 in keyof T_15]-?: T_15[K_8] extends infer T_17 ? T_17 extends T_15[K_8] ? T_17 extends CanBeExpanded ? any : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_9 in keyof T_17]-?: any; } : T_17 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_9 in keyof T_14]-?: T_14[K_9] extends infer T_17 ? T_17 extends T_14[K_9] ? T_17 extends CanBeExpanded ? T_17[PrefixWith<`${string & K_5}`, K_9, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_5}`, K_9, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_17[PrefixWith<`${string & K_5}`, K_9, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_5}`, K_9, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_10 in keyof T_19]-?: any; } : T_19 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_11 in keyof T_17]-?: T_17[K_11] extends infer T_20 ? T_20 extends T_17[K_11] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_12 in keyof T_20]-?: T_20[K_12] extends infer T_21 ? T_21 extends T_20[K_12] ? T_21 extends CanBeExpanded ? T_21["default"] : T_21 : never : never; } : T_20 : never : never; } : T_17 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_10 in keyof T_12]-?: T_12[K_10] extends infer T_17 ? T_17 extends T_12[K_10] ? T_17 extends CanBeExpanded ? T_17[PrefixWith<`${string & K_5}`, K_10, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_5}`, K_10, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_17[PrefixWith<`${string & K_5}`, K_10, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_5}`, K_10, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_5}`, K_10, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_5}`, K_10, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[PrefixWith<`${string & K_5}`, K_10, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_5}`, K_10, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_11 in keyof T_20]-?: any; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_12 in keyof T_19]-?: T_19[K_12] extends infer T_21 ? T_21 extends T_19[K_12] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_13 in keyof T_21]-?: T_21[K_13] extends infer T_22 ? T_22 extends T_21[K_13] ? T_22 extends CanBeExpanded ? T_22["default"] : T_22 : never : never; } : T_21 : never : never; } : T_19 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_13 in keyof T_17]-?: T_17[K_13] extends infer T_21 ? T_21 extends T_17[K_13] ? T_21 extends CanBeExpanded ? T_21[PrefixWith, K_13, "."> extends infer T_22 ? T_22 extends PrefixWith, K_13, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith, K_13, "."> extends infer T_22 ? T_22 extends PrefixWith, K_13, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_14 in keyof T_23]-?: T_23[K_14] extends infer T_24 ? T_24 extends T_23[K_14] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_15 in keyof T_21]-?: T_21[K_15] extends infer T_24 ? T_24 extends T_21[K_15] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_21 : never : never; } : T_17 : never : never; } : T_12 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_6 in keyof T_6]-?: T_6[K_6] extends infer T_12 ? T_12 extends T_6[K_6] ? T_12 extends CanBeExpanded ? T_12[`${string & K_6}` extends infer T_13 ? T_13 extends `${string & K_6}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_6}` extends infer T_13 ? T_13 extends `${string & K_6}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_6}` extends infer T_13 ? T_13 extends `${string & K_6}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_6}` extends infer T_13 ? T_13 extends `${string & K_6}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_6}` extends infer T_13 ? T_13 extends `${string & K_6}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_6}` extends infer T_13 ? T_13 extends `${string & K_6}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_6}` extends infer T_13 ? T_13 extends `${string & K_6}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_6}` extends infer T_13 ? T_13 extends `${string & K_6}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? any : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_8 in keyof T_17]-?: any; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_9 in keyof T_16]-?: T_16[K_9] extends infer T_18 ? T_18 extends T_16[K_9] ? T_18 extends CanBeExpanded ? any : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_10 in keyof T_18]-?: any; } : T_18 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_10 in keyof T_15]-?: T_15[K_10] extends infer T_18 ? T_18 extends T_15[K_10] ? T_18 extends CanBeExpanded ? T_18[PrefixWith<`${string & K_6}`, K_10, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_10, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_18[PrefixWith<`${string & K_6}`, K_10, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_10, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_11 in keyof T_20]-?: any; } : T_20 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_12 in keyof T_18]-?: T_18[K_12] extends infer T_21 ? T_21 extends T_18[K_12] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_13 in keyof T_21]-?: T_21[K_13] extends infer T_22 ? T_22 extends T_21[K_13] ? T_22 extends CanBeExpanded ? T_22["default"] : T_22 : never : never; } : T_21 : never : never; } : T_18 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_11 in keyof T_14]-?: T_14[K_11] extends infer T_18 ? T_18 extends T_14[K_11] ? T_18 extends CanBeExpanded ? T_18[PrefixWith<`${string & K_6}`, K_11, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_11, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_18[PrefixWith<`${string & K_6}`, K_11, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_11, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_6}`, K_11, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_11, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[PrefixWith<`${string & K_6}`, K_11, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_11, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_12 in keyof T_21]-?: any; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_13 in keyof T_20]-?: T_20[K_13] extends infer T_22 ? T_22 extends T_20[K_13] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_14 in keyof T_22]-?: T_22[K_14] extends infer T_23 ? T_23 extends T_22[K_14] ? T_23 extends CanBeExpanded ? T_23["default"] : T_23 : never : never; } : T_22 : never : never; } : T_20 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_14 in keyof T_18]-?: T_18[K_14] extends infer T_22 ? T_22 extends T_18[K_14] ? T_22 extends CanBeExpanded ? T_22[PrefixWith, K_14, "."> extends infer T_23 ? T_23 extends PrefixWith, K_14, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith, K_14, "."> extends infer T_23 ? T_23 extends PrefixWith, K_14, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_15 in keyof T_24]-?: T_24[K_15] extends infer T_25 ? T_25 extends T_24[K_15] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_16 in keyof T_22]-?: T_22[K_16] extends infer T_25 ? T_25 extends T_22[K_16] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_22 : never : never; } : T_18 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_12 in keyof T_12]-?: T_12[K_12] extends infer T_18 ? T_18 extends T_12[K_12] ? T_18 extends CanBeExpanded ? T_18[PrefixWith<`${string & K_6}`, K_12, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_12, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_18[PrefixWith<`${string & K_6}`, K_12, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_12, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_6}`, K_12, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_12, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[PrefixWith<`${string & K_6}`, K_12, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_12, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_6}`, K_12, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_12, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_6}`, K_12, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_12, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_13 in keyof T_22]-?: any; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_14 in keyof T_21]-?: T_21[K_14] extends infer T_23 ? T_23 extends T_21[K_14] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_15 in keyof T_23]-?: T_23[K_15] extends infer T_24 ? T_24 extends T_23[K_15] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_15 in keyof T_20]-?: T_20[K_15] extends infer T_23 ? T_23 extends T_20[K_15] ? T_23 extends CanBeExpanded ? T_23[PrefixWith, K_15, "."> extends infer T_24 ? T_24 extends PrefixWith, K_15, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith, K_15, "."> extends infer T_24 ? T_24 extends PrefixWith, K_15, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_16 in keyof T_25]-?: T_25[K_16] extends infer T_26 ? T_26 extends T_25[K_16] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_17 in keyof T_23]-?: T_23[K_17] extends infer T_26 ? T_26 extends T_23[K_17] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_23 : never : never; } : T_20 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_16 in keyof T_18]-?: T_18[K_16] extends infer T_23 ? T_23 extends T_18[K_16] ? T_23 extends CanBeExpanded ? T_23[PrefixWith, K_16, "."> extends infer T_24 ? T_24 extends PrefixWith, K_16, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith, K_16, "."> extends infer T_24 ? T_24 extends PrefixWith, K_16, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_16, "."> extends infer T_24 ? T_24 extends PrefixWith, K_16, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith, K_16, "."> extends infer T_24 ? T_24 extends PrefixWith, K_16, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_17 in keyof T_26]-?: T_26[K_17] extends infer T_27 ? T_27 extends T_26[K_17] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_18 in keyof T_25]-?: T_25[K_18] extends infer T_27 ? T_27 extends T_25[K_18] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_19 in keyof T_23]-?: T_23[K_19] extends infer T_27 ? T_27 extends T_23[K_19] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_23 : never : never; } : T_18 : never : never; } : T_12 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_7 in keyof T_5]-?: T_5[K_7] extends infer T_12 ? T_12 extends T_5[K_7] ? T_12 extends CanBeExpanded ? T_12[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? any : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_9 in keyof T_18]-?: any; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_10 in keyof T_17]-?: T_17[K_10] extends infer T_19 ? T_19 extends T_17[K_10] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_11 in keyof T_19]-?: any; } : T_19 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_11 in keyof T_16]-?: T_16[K_11] extends infer T_19 ? T_19 extends T_16[K_11] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_7}`, K_11, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_11, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_7}`, K_11, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_11, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_12 in keyof T_21]-?: any; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_13 in keyof T_19]-?: T_19[K_13] extends infer T_22 ? T_22 extends T_19[K_13] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_14 in keyof T_22]-?: T_22[K_14] extends infer T_23 ? T_23 extends T_22[K_14] ? T_23 extends CanBeExpanded ? T_23["default"] : T_23 : never : never; } : T_22 : never : never; } : T_19 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_12 in keyof T_15]-?: T_15[K_12] extends infer T_19 ? T_19 extends T_15[K_12] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_7}`, K_12, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_12, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_7}`, K_12, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_12, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_7}`, K_12, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_12, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_7}`, K_12, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_12, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_13 in keyof T_22]-?: any; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_14 in keyof T_21]-?: T_21[K_14] extends infer T_23 ? T_23 extends T_21[K_14] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_15 in keyof T_23]-?: T_23[K_15] extends infer T_24 ? T_24 extends T_23[K_15] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_15 in keyof T_19]-?: T_19[K_15] extends infer T_23 ? T_23 extends T_19[K_15] ? T_23 extends CanBeExpanded ? T_23[PrefixWith, K_15, "."> extends infer T_24 ? T_24 extends PrefixWith, K_15, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith, K_15, "."> extends infer T_24 ? T_24 extends PrefixWith, K_15, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_16 in keyof T_25]-?: T_25[K_16] extends infer T_26 ? T_26 extends T_25[K_16] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_17 in keyof T_23]-?: T_23[K_17] extends infer T_26 ? T_26 extends T_23[K_17] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_23 : never : never; } : T_19 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_13 in keyof T_14]-?: T_14[K_13] extends infer T_19 ? T_19 extends T_14[K_13] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_7}`, K_13, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_13, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_7}`, K_13, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_13, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_7}`, K_13, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_13, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_7}`, K_13, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_13, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_7}`, K_13, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_13, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_7}`, K_13, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_13, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_14 in keyof T_23]-?: any; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_15 in keyof T_22]-?: T_22[K_15] extends infer T_24 ? T_24 extends T_22[K_15] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_16 in keyof T_24]-?: T_24[K_16] extends infer T_25 ? T_25 extends T_24[K_16] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_16 in keyof T_21]-?: T_21[K_16] extends infer T_24 ? T_24 extends T_21[K_16] ? T_24 extends CanBeExpanded ? T_24[PrefixWith, K_16, "."> extends infer T_25 ? T_25 extends PrefixWith, K_16, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_24[PrefixWith, K_16, "."> extends infer T_25 ? T_25 extends PrefixWith, K_16, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_17 in keyof T_26]-?: T_26[K_17] extends infer T_27 ? T_27 extends T_26[K_17] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_18 in keyof T_24]-?: T_24[K_18] extends infer T_27 ? T_27 extends T_24[K_18] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_24 : never : never; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_17 in keyof T_19]-?: T_19[K_17] extends infer T_24 ? T_24 extends T_19[K_17] ? T_24 extends CanBeExpanded ? T_24[PrefixWith, K_17, "."> extends infer T_25 ? T_25 extends PrefixWith, K_17, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_24[PrefixWith, K_17, "."> extends infer T_25 ? T_25 extends PrefixWith, K_17, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_17, "."> extends infer T_25 ? T_25 extends PrefixWith, K_17, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith, K_17, "."> extends infer T_25 ? T_25 extends PrefixWith, K_17, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_18 in keyof T_27]-?: T_27[K_18] extends infer T_28 ? T_28 extends T_27[K_18] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_19 in keyof T_26]-?: T_26[K_19] extends infer T_28 ? T_28 extends T_26[K_19] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_26 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_20 in keyof T_24]-?: T_24[K_20] extends infer T_28 ? T_28 extends T_24[K_20] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_24 : never : never; } : T_19 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_14 in keyof T_12]-?: T_12[K_14] extends infer T_19 ? T_19 extends T_12[K_14] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_7}`, K_14, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_14, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_7}`, K_14, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_14, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_7}`, K_14, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_14, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_7}`, K_14, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_14, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_7}`, K_14, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_14, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_7}`, K_14, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_14, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_7}`, K_14, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_14, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_7}`, K_14, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_14, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_15 in keyof T_24]-?: any; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_16 in keyof T_23]-?: T_23[K_16] extends infer T_25 ? T_25 extends T_23[K_16] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_17 in keyof T_25]-?: T_25[K_17] extends infer T_26 ? T_26 extends T_25[K_17] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_17 in keyof T_22]-?: T_22[K_17] extends infer T_25 ? T_25 extends T_22[K_17] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_17, "."> extends infer T_26 ? T_26 extends PrefixWith, K_17, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_17, "."> extends infer T_26 ? T_26 extends PrefixWith, K_17, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_18 in keyof T_27]-?: T_27[K_18] extends infer T_28 ? T_28 extends T_27[K_18] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_19 in keyof T_25]-?: T_25[K_19] extends infer T_28 ? T_28 extends T_25[K_19] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_25 : never : never; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_18 in keyof T_21]-?: T_21[K_18] extends infer T_25 ? T_25 extends T_21[K_18] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_18, "."> extends infer T_26 ? T_26 extends PrefixWith, K_18, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_18, "."> extends infer T_26 ? T_26 extends PrefixWith, K_18, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_18, "."> extends infer T_26 ? T_26 extends PrefixWith, K_18, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith, K_18, "."> extends infer T_26 ? T_26 extends PrefixWith, K_18, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_19 in keyof T_28]-?: T_28[K_19] extends infer T_29 ? T_29 extends T_28[K_19] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_20 in keyof T_27]-?: T_27[K_20] extends infer T_29 ? T_29 extends T_27[K_20] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_21 in keyof T_25]-?: T_25[K_21] extends infer T_29 ? T_29 extends T_25[K_21] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_25 : never : never; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_19 in keyof T_19]-?: T_19[K_19] extends infer T_25 ? T_25 extends T_19[K_19] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_19, "."> extends infer T_26 ? T_26 extends PrefixWith, K_19, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_19, "."> extends infer T_26 ? T_26 extends PrefixWith, K_19, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_19, "."> extends infer T_26 ? T_26 extends PrefixWith, K_19, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith, K_19, "."> extends infer T_26 ? T_26 extends PrefixWith, K_19, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_19, "."> extends infer T_26 ? T_26 extends PrefixWith, K_19, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_19, "."> extends infer T_26 ? T_26 extends PrefixWith, K_19, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_20 in keyof T_29]-?: T_29[K_20] extends infer T_30 ? T_30 extends T_29[K_20] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_21 in keyof T_28]-?: T_28[K_21] extends infer T_30 ? T_30 extends T_28[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_22 in keyof T_27]-?: T_27[K_22] extends infer T_30 ? T_30 extends T_27[K_22] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_23 in keyof T_25]-?: T_25[K_23] extends infer T_30 ? T_30 extends T_25[K_23] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_25 : never : never; } : T_19 : never : never; } : T_12 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_8 in keyof T_4]-?: T_4[K_8] extends infer T_12 ? T_12 extends T_4[K_8] ? T_12 extends CanBeExpanded ? T_12[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_10 in keyof T_19]-?: any; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_11 in keyof T_18]-?: T_18[K_11] extends infer T_20 ? T_20 extends T_18[K_11] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_12 in keyof T_20]-?: any; } : T_20 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_12 in keyof T_17]-?: T_17[K_12] extends infer T_20 ? T_20 extends T_17[K_12] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_8}`, K_12, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_12, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_8}`, K_12, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_12, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_13 in keyof T_22]-?: any; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_14 in keyof T_20]-?: T_20[K_14] extends infer T_23 ? T_23 extends T_20[K_14] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_15 in keyof T_23]-?: T_23[K_15] extends infer T_24 ? T_24 extends T_23[K_15] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never; } : T_20 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_13 in keyof T_16]-?: T_16[K_13] extends infer T_20 ? T_20 extends T_16[K_13] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_8}`, K_13, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_13, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_8}`, K_13, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_13, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_8}`, K_13, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_13, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_8}`, K_13, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_13, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_14 in keyof T_23]-?: any; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_15 in keyof T_22]-?: T_22[K_15] extends infer T_24 ? T_24 extends T_22[K_15] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_16 in keyof T_24]-?: T_24[K_16] extends infer T_25 ? T_25 extends T_24[K_16] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_16 in keyof T_20]-?: T_20[K_16] extends infer T_24 ? T_24 extends T_20[K_16] ? T_24 extends CanBeExpanded ? T_24[PrefixWith, K_16, "."> extends infer T_25 ? T_25 extends PrefixWith, K_16, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_24[PrefixWith, K_16, "."> extends infer T_25 ? T_25 extends PrefixWith, K_16, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_17 in keyof T_26]-?: T_26[K_17] extends infer T_27 ? T_27 extends T_26[K_17] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_18 in keyof T_24]-?: T_24[K_18] extends infer T_27 ? T_27 extends T_24[K_18] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_24 : never : never; } : T_20 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_14 in keyof T_15]-?: T_15[K_14] extends infer T_20 ? T_20 extends T_15[K_14] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_8}`, K_14, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_14, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_8}`, K_14, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_14, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_8}`, K_14, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_14, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_8}`, K_14, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_14, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_8}`, K_14, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_14, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_8}`, K_14, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_14, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_15 in keyof T_24]-?: any; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_16 in keyof T_23]-?: T_23[K_16] extends infer T_25 ? T_25 extends T_23[K_16] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_17 in keyof T_25]-?: T_25[K_17] extends infer T_26 ? T_26 extends T_25[K_17] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_17 in keyof T_22]-?: T_22[K_17] extends infer T_25 ? T_25 extends T_22[K_17] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_17, "."> extends infer T_26 ? T_26 extends PrefixWith, K_17, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_17, "."> extends infer T_26 ? T_26 extends PrefixWith, K_17, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_18 in keyof T_27]-?: T_27[K_18] extends infer T_28 ? T_28 extends T_27[K_18] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_19 in keyof T_25]-?: T_25[K_19] extends infer T_28 ? T_28 extends T_25[K_19] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_25 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_18 in keyof T_20]-?: T_20[K_18] extends infer T_25 ? T_25 extends T_20[K_18] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_18, "."> extends infer T_26 ? T_26 extends PrefixWith, K_18, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_18, "."> extends infer T_26 ? T_26 extends PrefixWith, K_18, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_18, "."> extends infer T_26 ? T_26 extends PrefixWith, K_18, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith, K_18, "."> extends infer T_26 ? T_26 extends PrefixWith, K_18, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_19 in keyof T_28]-?: T_28[K_19] extends infer T_29 ? T_29 extends T_28[K_19] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_20 in keyof T_27]-?: T_27[K_20] extends infer T_29 ? T_29 extends T_27[K_20] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_21 in keyof T_25]-?: T_25[K_21] extends infer T_29 ? T_29 extends T_25[K_21] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_25 : never : never; } : T_20 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_15 in keyof T_14]-?: T_14[K_15] extends infer T_20 ? T_20 extends T_14[K_15] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_8}`, K_15, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_15, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_8}`, K_15, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_15, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_8}`, K_15, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_15, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_8}`, K_15, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_15, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_8}`, K_15, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_15, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_8}`, K_15, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_15, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_8}`, K_15, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_15, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_8}`, K_15, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_15, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_16 in keyof T_25]-?: any; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_17 in keyof T_24]-?: T_24[K_17] extends infer T_26 ? T_26 extends T_24[K_17] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_18 in keyof T_26]-?: T_26[K_18] extends infer T_27 ? T_27 extends T_26[K_18] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_18 in keyof T_23]-?: T_23[K_18] extends infer T_26 ? T_26 extends T_23[K_18] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_18, "."> extends infer T_27 ? T_27 extends PrefixWith, K_18, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_18, "."> extends infer T_27 ? T_27 extends PrefixWith, K_18, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_19 in keyof T_28]-?: T_28[K_19] extends infer T_29 ? T_29 extends T_28[K_19] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_20 in keyof T_26]-?: T_26[K_20] extends infer T_29 ? T_29 extends T_26[K_20] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_26 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_19 in keyof T_22]-?: T_22[K_19] extends infer T_26 ? T_26 extends T_22[K_19] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_19, "."> extends infer T_27 ? T_27 extends PrefixWith, K_19, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_19, "."> extends infer T_27 ? T_27 extends PrefixWith, K_19, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_19, "."> extends infer T_27 ? T_27 extends PrefixWith, K_19, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_19, "."> extends infer T_27 ? T_27 extends PrefixWith, K_19, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_20 in keyof T_29]-?: T_29[K_20] extends infer T_30 ? T_30 extends T_29[K_20] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_21 in keyof T_28]-?: T_28[K_21] extends infer T_30 ? T_30 extends T_28[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_22 in keyof T_26]-?: T_26[K_22] extends infer T_30 ? T_30 extends T_26[K_22] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_26 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_20 in keyof T_20]-?: T_20[K_20] extends infer T_26 ? T_26 extends T_20[K_20] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_20, "."> extends infer T_27 ? T_27 extends PrefixWith, K_20, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_20, "."> extends infer T_27 ? T_27 extends PrefixWith, K_20, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_20, "."> extends infer T_27 ? T_27 extends PrefixWith, K_20, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_20, "."> extends infer T_27 ? T_27 extends PrefixWith, K_20, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_20, "."> extends infer T_27 ? T_27 extends PrefixWith, K_20, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_20, "."> extends infer T_27 ? T_27 extends PrefixWith, K_20, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_21 in keyof T_30]-?: T_30[K_21] extends infer T_31 ? T_31 extends T_30[K_21] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_22 in keyof T_29]-?: T_29[K_22] extends infer T_31 ? T_31 extends T_29[K_22] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_23 in keyof T_28]-?: T_28[K_23] extends infer T_31 ? T_31 extends T_28[K_23] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_24 in keyof T_26]-?: T_26[K_24] extends infer T_31 ? T_31 extends T_26[K_24] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_26 : never : never; } : T_20 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_16 in keyof T_12]-?: T_12[K_16] extends infer T_20 ? T_20 extends T_12[K_16] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_17 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_18 in keyof T_25]-?: T_25[K_18] extends infer T_27 ? T_27 extends T_25[K_18] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_19 in keyof T_27]-?: T_27[K_19] extends infer T_28 ? T_28 extends T_27[K_19] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_19 in keyof T_24]-?: T_24[K_19] extends infer T_27 ? T_27 extends T_24[K_19] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_19, "."> extends infer T_28 ? T_28 extends PrefixWith, K_19, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_19, "."> extends infer T_28 ? T_28 extends PrefixWith, K_19, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_20 in keyof T_29]-?: T_29[K_20] extends infer T_30 ? T_30 extends T_29[K_20] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_21 in keyof T_27]-?: T_27[K_21] extends infer T_30 ? T_30 extends T_27[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_20 in keyof T_23]-?: T_23[K_20] extends infer T_27 ? T_27 extends T_23[K_20] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_21 in keyof T_30]-?: T_30[K_21] extends infer T_31 ? T_31 extends T_30[K_21] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_22 in keyof T_29]-?: T_29[K_22] extends infer T_31 ? T_31 extends T_29[K_22] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_23 in keyof T_27]-?: T_27[K_23] extends infer T_31 ? T_31 extends T_27[K_23] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_27 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_21 in keyof T_22]-?: T_22[K_21] extends infer T_27 ? T_27 extends T_22[K_21] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_22 in keyof T_31]-?: T_31[K_22] extends infer T_32 ? T_32 extends T_31[K_22] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_23 in keyof T_30]-?: T_30[K_23] extends infer T_32 ? T_32 extends T_30[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_24 in keyof T_29]-?: T_29[K_24] extends infer T_32 ? T_32 extends T_29[K_24] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_25 in keyof T_27]-?: T_27[K_25] extends infer T_32 ? T_32 extends T_27[K_25] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_27 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_22 in keyof T_20]-?: T_20[K_22] extends infer T_27 ? T_27 extends T_20[K_22] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_22, "."> extends infer T_28 ? T_28 extends PrefixWith, K_22, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_22, "."> extends infer T_28 ? T_28 extends PrefixWith, K_22, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_22, "."> extends infer T_28 ? T_28 extends PrefixWith, K_22, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_22, "."> extends infer T_28 ? T_28 extends PrefixWith, K_22, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_22, "."> extends infer T_28 ? T_28 extends PrefixWith, K_22, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_22, "."> extends infer T_28 ? T_28 extends PrefixWith, K_22, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_22, "."> extends infer T_28 ? T_28 extends PrefixWith, K_22, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_22, "."> extends infer T_28 ? T_28 extends PrefixWith, K_22, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_23 in keyof T_32]-?: T_32[K_23] extends infer T_33 ? T_33 extends T_32[K_23] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_24 in keyof T_31]-?: T_31[K_24] extends infer T_33 ? T_33 extends T_31[K_24] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_25 in keyof T_30]-?: T_30[K_25] extends infer T_33 ? T_33 extends T_30[K_25] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_26 in keyof T_29]-?: T_29[K_26] extends infer T_33 ? T_33 extends T_29[K_26] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_27 in keyof T_27]-?: T_27[K_27] extends infer T_33 ? T_33 extends T_27[K_27] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_27 : never : never; } : T_20 : never : never; } : T_12 : never : never; } : T_4 : never : never : T_3 extends (infer U)[] ? any[] : T_3 extends object ? { [K_9 in keyof T_3]-?: T_3[K_9] extends infer T_12 ? T_12 extends T_3[K_9] ? T_12 extends CanBeExpanded ? T_12[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_11 in keyof T_20]-?: any; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_12 in keyof T_19]-?: T_19[K_12] extends infer T_21 ? T_21 extends T_19[K_12] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_13 in keyof T_21]-?: any; } : T_21 : never : never; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_13 in keyof T_18]-?: T_18[K_13] extends infer T_21 ? T_21 extends T_18[K_13] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_9}`, K_13, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_13, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_9}`, K_13, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_13, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_14 in keyof T_23]-?: any; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_15 in keyof T_21]-?: T_21[K_15] extends infer T_24 ? T_24 extends T_21[K_15] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_16 in keyof T_24]-?: T_24[K_16] extends infer T_25 ? T_25 extends T_24[K_16] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never; } : T_21 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_14 in keyof T_17]-?: T_17[K_14] extends infer T_21 ? T_21 extends T_17[K_14] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_9}`, K_14, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_14, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_9}`, K_14, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_14, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_9}`, K_14, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_14, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_9}`, K_14, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_14, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_15 in keyof T_24]-?: any; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_16 in keyof T_23]-?: T_23[K_16] extends infer T_25 ? T_25 extends T_23[K_16] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_17 in keyof T_25]-?: T_25[K_17] extends infer T_26 ? T_26 extends T_25[K_17] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_17 in keyof T_21]-?: T_21[K_17] extends infer T_25 ? T_25 extends T_21[K_17] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_17, "."> extends infer T_26 ? T_26 extends PrefixWith, K_17, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_17, "."> extends infer T_26 ? T_26 extends PrefixWith, K_17, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_18 in keyof T_27]-?: T_27[K_18] extends infer T_28 ? T_28 extends T_27[K_18] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_19 in keyof T_25]-?: T_25[K_19] extends infer T_28 ? T_28 extends T_25[K_19] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_25 : never : never; } : T_21 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_15 in keyof T_16]-?: T_16[K_15] extends infer T_21 ? T_21 extends T_16[K_15] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_9}`, K_15, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_15, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_9}`, K_15, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_15, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_9}`, K_15, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_15, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_9}`, K_15, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_15, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_9}`, K_15, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_15, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_9}`, K_15, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_15, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_16 in keyof T_25]-?: any; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_17 in keyof T_24]-?: T_24[K_17] extends infer T_26 ? T_26 extends T_24[K_17] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_18 in keyof T_26]-?: T_26[K_18] extends infer T_27 ? T_27 extends T_26[K_18] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_18 in keyof T_23]-?: T_23[K_18] extends infer T_26 ? T_26 extends T_23[K_18] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_18, "."> extends infer T_27 ? T_27 extends PrefixWith, K_18, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_18, "."> extends infer T_27 ? T_27 extends PrefixWith, K_18, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_19 in keyof T_28]-?: T_28[K_19] extends infer T_29 ? T_29 extends T_28[K_19] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_20 in keyof T_26]-?: T_26[K_20] extends infer T_29 ? T_29 extends T_26[K_20] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_26 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_19 in keyof T_21]-?: T_21[K_19] extends infer T_26 ? T_26 extends T_21[K_19] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_19, "."> extends infer T_27 ? T_27 extends PrefixWith, K_19, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_19, "."> extends infer T_27 ? T_27 extends PrefixWith, K_19, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_19, "."> extends infer T_27 ? T_27 extends PrefixWith, K_19, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_19, "."> extends infer T_27 ? T_27 extends PrefixWith, K_19, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_20 in keyof T_29]-?: T_29[K_20] extends infer T_30 ? T_30 extends T_29[K_20] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_21 in keyof T_28]-?: T_28[K_21] extends infer T_30 ? T_30 extends T_28[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_22 in keyof T_26]-?: T_26[K_22] extends infer T_30 ? T_30 extends T_26[K_22] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_26 : never : never; } : T_21 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_16 in keyof T_15]-?: T_15[K_16] extends infer T_21 ? T_21 extends T_15[K_16] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_9}`, K_16, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_16, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_9}`, K_16, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_16, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_9}`, K_16, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_16, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_9}`, K_16, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_16, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_9}`, K_16, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_16, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_9}`, K_16, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_16, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_9}`, K_16, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_16, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_9}`, K_16, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_16, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_17 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_18 in keyof T_25]-?: T_25[K_18] extends infer T_27 ? T_27 extends T_25[K_18] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_19 in keyof T_27]-?: T_27[K_19] extends infer T_28 ? T_28 extends T_27[K_19] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_19 in keyof T_24]-?: T_24[K_19] extends infer T_27 ? T_27 extends T_24[K_19] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_19, "."> extends infer T_28 ? T_28 extends PrefixWith, K_19, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_19, "."> extends infer T_28 ? T_28 extends PrefixWith, K_19, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_20 in keyof T_29]-?: T_29[K_20] extends infer T_30 ? T_30 extends T_29[K_20] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_21 in keyof T_27]-?: T_27[K_21] extends infer T_30 ? T_30 extends T_27[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_20 in keyof T_23]-?: T_23[K_20] extends infer T_27 ? T_27 extends T_23[K_20] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_21 in keyof T_30]-?: T_30[K_21] extends infer T_31 ? T_31 extends T_30[K_21] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_22 in keyof T_29]-?: T_29[K_22] extends infer T_31 ? T_31 extends T_29[K_22] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_23 in keyof T_27]-?: T_27[K_23] extends infer T_31 ? T_31 extends T_27[K_23] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_27 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_21 in keyof T_21]-?: T_21[K_21] extends infer T_27 ? T_27 extends T_21[K_21] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_22 in keyof T_31]-?: T_31[K_22] extends infer T_32 ? T_32 extends T_31[K_22] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_23 in keyof T_30]-?: T_30[K_23] extends infer T_32 ? T_32 extends T_30[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_24 in keyof T_29]-?: T_29[K_24] extends infer T_32 ? T_32 extends T_29[K_24] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_25 in keyof T_27]-?: T_27[K_25] extends infer T_32 ? T_32 extends T_27[K_25] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_27 : never : never; } : T_21 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_17 in keyof T_14]-?: T_14[K_17] extends infer T_21 ? T_21 extends T_14[K_17] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_18 in keyof T_27]-?: any; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_19 in keyof T_26]-?: T_26[K_19] extends infer T_28 ? T_28 extends T_26[K_19] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_20 in keyof T_28]-?: T_28[K_20] extends infer T_29 ? T_29 extends T_28[K_20] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_20 in keyof T_25]-?: T_25[K_20] extends infer T_28 ? T_28 extends T_25[K_20] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_20, "."> extends infer T_29 ? T_29 extends PrefixWith, K_20, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_20, "."> extends infer T_29 ? T_29 extends PrefixWith, K_20, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_21 in keyof T_30]-?: T_30[K_21] extends infer T_31 ? T_31 extends T_30[K_21] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_22 in keyof T_28]-?: T_28[K_22] extends infer T_31 ? T_31 extends T_28[K_22] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_21 in keyof T_24]-?: T_24[K_21] extends infer T_28 ? T_28 extends T_24[K_21] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_22 in keyof T_31]-?: T_31[K_22] extends infer T_32 ? T_32 extends T_31[K_22] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_23 in keyof T_30]-?: T_30[K_23] extends infer T_32 ? T_32 extends T_30[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_24 in keyof T_28]-?: T_28[K_24] extends infer T_32 ? T_32 extends T_28[K_24] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_28 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_22 in keyof T_23]-?: T_23[K_22] extends infer T_28 ? T_28 extends T_23[K_22] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_23 in keyof T_32]-?: T_32[K_23] extends infer T_33 ? T_33 extends T_32[K_23] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_24 in keyof T_31]-?: T_31[K_24] extends infer T_33 ? T_33 extends T_31[K_24] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_25 in keyof T_30]-?: T_30[K_25] extends infer T_33 ? T_33 extends T_30[K_25] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_26 in keyof T_28]-?: T_28[K_26] extends infer T_33 ? T_33 extends T_28[K_26] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_28 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_23 in keyof T_21]-?: T_21[K_23] extends infer T_28 ? T_28 extends T_21[K_23] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_23, "."> extends infer T_29 ? T_29 extends PrefixWith, K_23, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_23, "."> extends infer T_29 ? T_29 extends PrefixWith, K_23, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_23, "."> extends infer T_29 ? T_29 extends PrefixWith, K_23, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_23, "."> extends infer T_29 ? T_29 extends PrefixWith, K_23, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_23, "."> extends infer T_29 ? T_29 extends PrefixWith, K_23, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_23, "."> extends infer T_29 ? T_29 extends PrefixWith, K_23, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_23, "."> extends infer T_29 ? T_29 extends PrefixWith, K_23, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_23, "."> extends infer T_29 ? T_29 extends PrefixWith, K_23, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_24 in keyof T_33]-?: T_33[K_24] extends infer T_34 ? T_34 extends T_33[K_24] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_25 in keyof T_32]-?: T_32[K_25] extends infer T_34 ? T_34 extends T_32[K_25] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_26 in keyof T_31]-?: T_31[K_26] extends infer T_34 ? T_34 extends T_31[K_26] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_27 in keyof T_30]-?: T_30[K_27] extends infer T_34 ? T_34 extends T_30[K_27] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_28 in keyof T_28]-?: T_28[K_28] extends infer T_34 ? T_34 extends T_28[K_28] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_28 : never : never; } : T_21 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_18 in keyof T_12]-?: T_12[K_18] extends infer T_21 ? T_21 extends T_12[K_18] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_19 in keyof T_28]-?: any; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_20 in keyof T_27]-?: T_27[K_20] extends infer T_29 ? T_29 extends T_27[K_20] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_21 in keyof T_29]-?: T_29[K_21] extends infer T_30 ? T_30 extends T_29[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_21 in keyof T_26]-?: T_26[K_21] extends infer T_29 ? T_29 extends T_26[K_21] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_21, "."> extends infer T_30 ? T_30 extends PrefixWith, K_21, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_21, "."> extends infer T_30 ? T_30 extends PrefixWith, K_21, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_22 in keyof T_31]-?: T_31[K_22] extends infer T_32 ? T_32 extends T_31[K_22] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_23 in keyof T_29]-?: T_29[K_23] extends infer T_32 ? T_32 extends T_29[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_22 in keyof T_25]-?: T_25[K_22] extends infer T_29 ? T_29 extends T_25[K_22] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_23 in keyof T_32]-?: T_32[K_23] extends infer T_33 ? T_33 extends T_32[K_23] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_24 in keyof T_31]-?: T_31[K_24] extends infer T_33 ? T_33 extends T_31[K_24] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_25 in keyof T_29]-?: T_29[K_25] extends infer T_33 ? T_33 extends T_29[K_25] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_23 in keyof T_24]-?: T_24[K_23] extends infer T_29 ? T_29 extends T_24[K_23] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_24 in keyof T_33]-?: T_33[K_24] extends infer T_34 ? T_34 extends T_33[K_24] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_25 in keyof T_32]-?: T_32[K_25] extends infer T_34 ? T_34 extends T_32[K_25] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_26 in keyof T_31]-?: T_31[K_26] extends infer T_34 ? T_34 extends T_31[K_26] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_27 in keyof T_29]-?: T_29[K_27] extends infer T_34 ? T_34 extends T_29[K_27] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_29 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_24 in keyof T_23]-?: T_23[K_24] extends infer T_29 ? T_29 extends T_23[K_24] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_25 in keyof T_34]-?: T_34[K_25] extends infer T_35 ? T_35 extends T_34[K_25] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_26 in keyof T_33]-?: T_33[K_26] extends infer T_35 ? T_35 extends T_33[K_26] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_27 in keyof T_32]-?: T_32[K_27] extends infer T_35 ? T_35 extends T_32[K_27] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_28 in keyof T_31]-?: T_31[K_28] extends infer T_35 ? T_35 extends T_31[K_28] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_29 in keyof T_29]-?: T_29[K_29] extends infer T_35 ? T_35 extends T_29[K_29] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_29 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_25 in keyof T_21]-?: T_21[K_25] extends infer T_29 ? T_29 extends T_21[K_25] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_26 in keyof T_35]-?: T_35[K_26] extends infer T_36 ? T_36 extends T_35[K_26] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_27 in keyof T_34]-?: T_34[K_27] extends infer T_36 ? T_36 extends T_34[K_27] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_28 in keyof T_33]-?: T_33[K_28] extends infer T_36 ? T_36 extends T_33[K_28] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_29 in keyof T_32]-?: T_32[K_29] extends infer T_36 ? T_36 extends T_32[K_29] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_30 in keyof T_31]-?: T_31[K_30] extends infer T_36 ? T_36 extends T_31[K_30] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_31 in keyof T_29]-?: T_29[K_31] extends infer T_36 ? T_36 extends T_29[K_31] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_29 : never : never; } : T_21 : never : never; } : T_12 : never : never; } : T_3 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_10 in keyof T_2]-?: T_2[K_10] extends infer T_12 ? T_12 extends T_2[K_10] ? T_12 extends CanBeExpanded ? T_12[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_12 in keyof T_21]-?: any; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_13 in keyof T_20]-?: T_20[K_13] extends infer T_22 ? T_22 extends T_20[K_13] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_14 in keyof T_22]-?: any; } : T_22 : never : never; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_14 in keyof T_19]-?: T_19[K_14] extends infer T_22 ? T_22 extends T_19[K_14] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_10}`, K_14, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_14, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_10}`, K_14, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_14, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_15 in keyof T_24]-?: any; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_16 in keyof T_22]-?: T_22[K_16] extends infer T_25 ? T_25 extends T_22[K_16] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_17 in keyof T_25]-?: T_25[K_17] extends infer T_26 ? T_26 extends T_25[K_17] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_22 : never : never; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_15 in keyof T_18]-?: T_18[K_15] extends infer T_22 ? T_22 extends T_18[K_15] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_10}`, K_15, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_15, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_10}`, K_15, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_15, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_10}`, K_15, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_15, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_10}`, K_15, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_15, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_16 in keyof T_25]-?: any; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_17 in keyof T_24]-?: T_24[K_17] extends infer T_26 ? T_26 extends T_24[K_17] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_18 in keyof T_26]-?: T_26[K_18] extends infer T_27 ? T_27 extends T_26[K_18] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_18 in keyof T_22]-?: T_22[K_18] extends infer T_26 ? T_26 extends T_22[K_18] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_18, "."> extends infer T_27 ? T_27 extends PrefixWith, K_18, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_18, "."> extends infer T_27 ? T_27 extends PrefixWith, K_18, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_19 in keyof T_28]-?: T_28[K_19] extends infer T_29 ? T_29 extends T_28[K_19] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_20 in keyof T_26]-?: T_26[K_20] extends infer T_29 ? T_29 extends T_26[K_20] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_26 : never : never; } : T_22 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_16 in keyof T_17]-?: T_17[K_16] extends infer T_22 ? T_22 extends T_17[K_16] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_10}`, K_16, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_16, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_10}`, K_16, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_16, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_10}`, K_16, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_16, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_10}`, K_16, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_16, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_10}`, K_16, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_16, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_10}`, K_16, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_16, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_17 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_18 in keyof T_25]-?: T_25[K_18] extends infer T_27 ? T_27 extends T_25[K_18] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_19 in keyof T_27]-?: T_27[K_19] extends infer T_28 ? T_28 extends T_27[K_19] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_19 in keyof T_24]-?: T_24[K_19] extends infer T_27 ? T_27 extends T_24[K_19] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_19, "."> extends infer T_28 ? T_28 extends PrefixWith, K_19, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_19, "."> extends infer T_28 ? T_28 extends PrefixWith, K_19, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_20 in keyof T_29]-?: T_29[K_20] extends infer T_30 ? T_30 extends T_29[K_20] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_21 in keyof T_27]-?: T_27[K_21] extends infer T_30 ? T_30 extends T_27[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_20 in keyof T_22]-?: T_22[K_20] extends infer T_27 ? T_27 extends T_22[K_20] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_21 in keyof T_30]-?: T_30[K_21] extends infer T_31 ? T_31 extends T_30[K_21] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_22 in keyof T_29]-?: T_29[K_22] extends infer T_31 ? T_31 extends T_29[K_22] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_23 in keyof T_27]-?: T_27[K_23] extends infer T_31 ? T_31 extends T_27[K_23] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_27 : never : never; } : T_22 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_17 in keyof T_16]-?: T_16[K_17] extends infer T_22 ? T_22 extends T_16[K_17] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_10}`, K_17, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_17, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_10}`, K_17, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_17, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_10}`, K_17, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_17, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_10}`, K_17, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_17, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_10}`, K_17, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_17, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_10}`, K_17, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_17, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_10}`, K_17, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_17, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_10}`, K_17, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_17, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_18 in keyof T_27]-?: any; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_19 in keyof T_26]-?: T_26[K_19] extends infer T_28 ? T_28 extends T_26[K_19] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_20 in keyof T_28]-?: T_28[K_20] extends infer T_29 ? T_29 extends T_28[K_20] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_20 in keyof T_25]-?: T_25[K_20] extends infer T_28 ? T_28 extends T_25[K_20] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_20, "."> extends infer T_29 ? T_29 extends PrefixWith, K_20, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_20, "."> extends infer T_29 ? T_29 extends PrefixWith, K_20, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_21 in keyof T_30]-?: T_30[K_21] extends infer T_31 ? T_31 extends T_30[K_21] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_22 in keyof T_28]-?: T_28[K_22] extends infer T_31 ? T_31 extends T_28[K_22] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_21 in keyof T_24]-?: T_24[K_21] extends infer T_28 ? T_28 extends T_24[K_21] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_22 in keyof T_31]-?: T_31[K_22] extends infer T_32 ? T_32 extends T_31[K_22] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_23 in keyof T_30]-?: T_30[K_23] extends infer T_32 ? T_32 extends T_30[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_24 in keyof T_28]-?: T_28[K_24] extends infer T_32 ? T_32 extends T_28[K_24] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_28 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_22 in keyof T_22]-?: T_22[K_22] extends infer T_28 ? T_28 extends T_22[K_22] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_23 in keyof T_32]-?: T_32[K_23] extends infer T_33 ? T_33 extends T_32[K_23] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_24 in keyof T_31]-?: T_31[K_24] extends infer T_33 ? T_33 extends T_31[K_24] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_25 in keyof T_30]-?: T_30[K_25] extends infer T_33 ? T_33 extends T_30[K_25] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_26 in keyof T_28]-?: T_28[K_26] extends infer T_33 ? T_33 extends T_28[K_26] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_28 : never : never; } : T_22 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_18 in keyof T_15]-?: T_15[K_18] extends infer T_22 ? T_22 extends T_15[K_18] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_19 in keyof T_28]-?: any; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_20 in keyof T_27]-?: T_27[K_20] extends infer T_29 ? T_29 extends T_27[K_20] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_21 in keyof T_29]-?: T_29[K_21] extends infer T_30 ? T_30 extends T_29[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_21 in keyof T_26]-?: T_26[K_21] extends infer T_29 ? T_29 extends T_26[K_21] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_21, "."> extends infer T_30 ? T_30 extends PrefixWith, K_21, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_21, "."> extends infer T_30 ? T_30 extends PrefixWith, K_21, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_22 in keyof T_31]-?: T_31[K_22] extends infer T_32 ? T_32 extends T_31[K_22] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_23 in keyof T_29]-?: T_29[K_23] extends infer T_32 ? T_32 extends T_29[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_22 in keyof T_25]-?: T_25[K_22] extends infer T_29 ? T_29 extends T_25[K_22] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_23 in keyof T_32]-?: T_32[K_23] extends infer T_33 ? T_33 extends T_32[K_23] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_24 in keyof T_31]-?: T_31[K_24] extends infer T_33 ? T_33 extends T_31[K_24] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_25 in keyof T_29]-?: T_29[K_25] extends infer T_33 ? T_33 extends T_29[K_25] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_23 in keyof T_24]-?: T_24[K_23] extends infer T_29 ? T_29 extends T_24[K_23] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_24 in keyof T_33]-?: T_33[K_24] extends infer T_34 ? T_34 extends T_33[K_24] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_25 in keyof T_32]-?: T_32[K_25] extends infer T_34 ? T_34 extends T_32[K_25] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_26 in keyof T_31]-?: T_31[K_26] extends infer T_34 ? T_34 extends T_31[K_26] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_27 in keyof T_29]-?: T_29[K_27] extends infer T_34 ? T_34 extends T_29[K_27] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_29 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_24 in keyof T_22]-?: T_22[K_24] extends infer T_29 ? T_29 extends T_22[K_24] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_25 in keyof T_34]-?: T_34[K_25] extends infer T_35 ? T_35 extends T_34[K_25] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_26 in keyof T_33]-?: T_33[K_26] extends infer T_35 ? T_35 extends T_33[K_26] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_27 in keyof T_32]-?: T_32[K_27] extends infer T_35 ? T_35 extends T_32[K_27] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_28 in keyof T_31]-?: T_31[K_28] extends infer T_35 ? T_35 extends T_31[K_28] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_29 in keyof T_29]-?: T_29[K_29] extends infer T_35 ? T_35 extends T_29[K_29] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_29 : never : never; } : T_22 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_19 in keyof T_14]-?: T_14[K_19] extends infer T_22 ? T_22 extends T_14[K_19] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_20 in keyof T_29]-?: any; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_21 in keyof T_28]-?: T_28[K_21] extends infer T_30 ? T_30 extends T_28[K_21] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_22 in keyof T_30]-?: T_30[K_22] extends infer T_31 ? T_31 extends T_30[K_22] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_22 in keyof T_27]-?: T_27[K_22] extends infer T_30 ? T_30 extends T_27[K_22] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_22, "."> extends infer T_31 ? T_31 extends PrefixWith, K_22, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_22, "."> extends infer T_31 ? T_31 extends PrefixWith, K_22, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_23 in keyof T_32]-?: T_32[K_23] extends infer T_33 ? T_33 extends T_32[K_23] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_24 in keyof T_30]-?: T_30[K_24] extends infer T_33 ? T_33 extends T_30[K_24] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_23 in keyof T_26]-?: T_26[K_23] extends infer T_30 ? T_30 extends T_26[K_23] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_23, "."> extends infer T_31 ? T_31 extends PrefixWith, K_23, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_23, "."> extends infer T_31 ? T_31 extends PrefixWith, K_23, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_23, "."> extends infer T_31 ? T_31 extends PrefixWith, K_23, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_23, "."> extends infer T_31 ? T_31 extends PrefixWith, K_23, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_24 in keyof T_33]-?: T_33[K_24] extends infer T_34 ? T_34 extends T_33[K_24] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_25 in keyof T_32]-?: T_32[K_25] extends infer T_34 ? T_34 extends T_32[K_25] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_26 in keyof T_30]-?: T_30[K_26] extends infer T_34 ? T_34 extends T_30[K_26] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_30 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_24 in keyof T_25]-?: T_25[K_24] extends infer T_30 ? T_30 extends T_25[K_24] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_25 in keyof T_34]-?: T_34[K_25] extends infer T_35 ? T_35 extends T_34[K_25] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_26 in keyof T_33]-?: T_33[K_26] extends infer T_35 ? T_35 extends T_33[K_26] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_27 in keyof T_32]-?: T_32[K_27] extends infer T_35 ? T_35 extends T_32[K_27] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_28 in keyof T_30]-?: T_30[K_28] extends infer T_35 ? T_35 extends T_30[K_28] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_30 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_25 in keyof T_24]-?: T_24[K_25] extends infer T_30 ? T_30 extends T_24[K_25] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_26 in keyof T_35]-?: T_35[K_26] extends infer T_36 ? T_36 extends T_35[K_26] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_27 in keyof T_34]-?: T_34[K_27] extends infer T_36 ? T_36 extends T_34[K_27] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_28 in keyof T_33]-?: T_33[K_28] extends infer T_36 ? T_36 extends T_33[K_28] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_29 in keyof T_32]-?: T_32[K_29] extends infer T_36 ? T_36 extends T_32[K_29] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_30 in keyof T_30]-?: T_30[K_30] extends infer T_36 ? T_36 extends T_30[K_30] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_30 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_26 in keyof T_22]-?: T_22[K_26] extends infer T_30 ? T_30 extends T_22[K_26] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_27 in keyof T_36]-?: T_36[K_27] extends infer T_37 ? T_37 extends T_36[K_27] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_28 in keyof T_35]-?: T_35[K_28] extends infer T_37 ? T_37 extends T_35[K_28] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_29 in keyof T_34]-?: T_34[K_29] extends infer T_37 ? T_37 extends T_34[K_29] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_30 in keyof T_33]-?: T_33[K_30] extends infer T_37 ? T_37 extends T_33[K_30] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_31 in keyof T_32]-?: T_32[K_31] extends infer T_37 ? T_37 extends T_32[K_31] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_32 in keyof T_30]-?: T_30[K_32] extends infer T_37 ? T_37 extends T_30[K_32] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_30 : never : never; } : T_22 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_20 in keyof T_12]-?: T_12[K_20] extends infer T_22 ? T_22 extends T_12[K_20] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_21 in keyof T_30]-?: any; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_22 in keyof T_29]-?: T_29[K_22] extends infer T_31 ? T_31 extends T_29[K_22] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_23 in keyof T_31]-?: T_31[K_23] extends infer T_32 ? T_32 extends T_31[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_23 in keyof T_28]-?: T_28[K_23] extends infer T_31 ? T_31 extends T_28[K_23] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_23, "."> extends infer T_32 ? T_32 extends PrefixWith, K_23, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_23, "."> extends infer T_32 ? T_32 extends PrefixWith, K_23, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_24 in keyof T_33]-?: T_33[K_24] extends infer T_34 ? T_34 extends T_33[K_24] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_25 in keyof T_31]-?: T_31[K_25] extends infer T_34 ? T_34 extends T_31[K_25] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_24 in keyof T_27]-?: T_27[K_24] extends infer T_31 ? T_31 extends T_27[K_24] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_24, "."> extends infer T_32 ? T_32 extends PrefixWith, K_24, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_24, "."> extends infer T_32 ? T_32 extends PrefixWith, K_24, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_24, "."> extends infer T_32 ? T_32 extends PrefixWith, K_24, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_24, "."> extends infer T_32 ? T_32 extends PrefixWith, K_24, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_25 in keyof T_34]-?: T_34[K_25] extends infer T_35 ? T_35 extends T_34[K_25] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_26 in keyof T_33]-?: T_33[K_26] extends infer T_35 ? T_35 extends T_33[K_26] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_27 in keyof T_31]-?: T_31[K_27] extends infer T_35 ? T_35 extends T_31[K_27] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_25 in keyof T_26]-?: T_26[K_25] extends infer T_31 ? T_31 extends T_26[K_25] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_26 in keyof T_35]-?: T_35[K_26] extends infer T_36 ? T_36 extends T_35[K_26] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_27 in keyof T_34]-?: T_34[K_27] extends infer T_36 ? T_36 extends T_34[K_27] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_28 in keyof T_33]-?: T_33[K_28] extends infer T_36 ? T_36 extends T_33[K_28] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_29 in keyof T_31]-?: T_31[K_29] extends infer T_36 ? T_36 extends T_31[K_29] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_31 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_26 in keyof T_25]-?: T_25[K_26] extends infer T_31 ? T_31 extends T_25[K_26] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_27 in keyof T_36]-?: T_36[K_27] extends infer T_37 ? T_37 extends T_36[K_27] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_28 in keyof T_35]-?: T_35[K_28] extends infer T_37 ? T_37 extends T_35[K_28] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_29 in keyof T_34]-?: T_34[K_29] extends infer T_37 ? T_37 extends T_34[K_29] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_30 in keyof T_33]-?: T_33[K_30] extends infer T_37 ? T_37 extends T_33[K_30] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_31 in keyof T_31]-?: T_31[K_31] extends infer T_37 ? T_37 extends T_31[K_31] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_31 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_27 in keyof T_24]-?: T_24[K_27] extends infer T_31 ? T_31 extends T_24[K_27] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_28 in keyof T_37]-?: T_37[K_28] extends infer T_38 ? T_38 extends T_37[K_28] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_29 in keyof T_36]-?: T_36[K_29] extends infer T_38 ? T_38 extends T_36[K_29] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_30 in keyof T_35]-?: T_35[K_30] extends infer T_38 ? T_38 extends T_35[K_30] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_31 in keyof T_34]-?: T_34[K_31] extends infer T_38 ? T_38 extends T_34[K_31] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_32 in keyof T_33]-?: T_33[K_32] extends infer T_38 ? T_38 extends T_33[K_32] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_33 in keyof T_31]-?: T_31[K_33] extends infer T_38 ? T_38 extends T_31[K_33] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_31 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_28 in keyof T_22]-?: T_22[K_28] extends infer T_31 ? T_31 extends T_22[K_28] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? any : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_29 in keyof T_38]-?: T_38[K_29] extends infer T_39 ? T_39 extends T_38[K_29] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_30 in keyof T_37]-?: T_37[K_30] extends infer T_39 ? T_39 extends T_37[K_30] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_31 in keyof T_36]-?: T_36[K_31] extends infer T_39 ? T_39 extends T_36[K_31] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_32 in keyof T_35]-?: T_35[K_32] extends infer T_39 ? T_39 extends T_35[K_32] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_33 in keyof T_34]-?: T_34[K_33] extends infer T_39 ? T_39 extends T_34[K_33] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_34 in keyof T_33]-?: T_33[K_34] extends infer T_39 ? T_39 extends T_33[K_34] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_35 in keyof T_31]-?: T_31[K_35] extends infer T_39 ? T_39 extends T_31[K_35] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_31 : never : never; } : T_22 : never : never; } : T_12 : never : never; } : T_2 : never : never : T extends (infer U)[] ? any[] : T extends object ? { [K_11 in keyof T]-?: T[K_11] extends infer T_12 ? T_12 extends T[K_11] ? T_12 extends CanBeExpanded ? T_12[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_13 in keyof T_22]-?: any; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_14 in keyof T_21]-?: T_21[K_14] extends infer T_23 ? T_23 extends T_21[K_14] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_15 in keyof T_23]-?: any; } : T_23 : never : never; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_15 in keyof T_20]-?: T_20[K_15] extends infer T_23 ? T_23 extends T_20[K_15] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_11}`, K_15, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_15, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_11}`, K_15, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_15, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_16 in keyof T_25]-?: any; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_17 in keyof T_23]-?: T_23[K_17] extends infer T_26 ? T_26 extends T_23[K_17] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_18 in keyof T_26]-?: T_26[K_18] extends infer T_27 ? T_27 extends T_26[K_18] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_23 : never : never; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_16 in keyof T_19]-?: T_19[K_16] extends infer T_23 ? T_23 extends T_19[K_16] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_11}`, K_16, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_16, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_11}`, K_16, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_16, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_11}`, K_16, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_16, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_11}`, K_16, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_16, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_17 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_18 in keyof T_25]-?: T_25[K_18] extends infer T_27 ? T_27 extends T_25[K_18] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_19 in keyof T_27]-?: T_27[K_19] extends infer T_28 ? T_28 extends T_27[K_19] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_19 in keyof T_23]-?: T_23[K_19] extends infer T_27 ? T_27 extends T_23[K_19] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_19, "."> extends infer T_28 ? T_28 extends PrefixWith, K_19, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_19, "."> extends infer T_28 ? T_28 extends PrefixWith, K_19, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_20 in keyof T_29]-?: T_29[K_20] extends infer T_30 ? T_30 extends T_29[K_20] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_21 in keyof T_27]-?: T_27[K_21] extends infer T_30 ? T_30 extends T_27[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_23 : never : never; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_17 in keyof T_18]-?: T_18[K_17] extends infer T_23 ? T_23 extends T_18[K_17] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_11}`, K_17, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_17, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_11}`, K_17, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_17, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_11}`, K_17, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_17, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_11}`, K_17, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_17, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_11}`, K_17, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_17, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_11}`, K_17, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_17, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_18 in keyof T_27]-?: any; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_19 in keyof T_26]-?: T_26[K_19] extends infer T_28 ? T_28 extends T_26[K_19] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_20 in keyof T_28]-?: T_28[K_20] extends infer T_29 ? T_29 extends T_28[K_20] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_20 in keyof T_25]-?: T_25[K_20] extends infer T_28 ? T_28 extends T_25[K_20] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_20, "."> extends infer T_29 ? T_29 extends PrefixWith, K_20, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_20, "."> extends infer T_29 ? T_29 extends PrefixWith, K_20, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_21 in keyof T_30]-?: T_30[K_21] extends infer T_31 ? T_31 extends T_30[K_21] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_22 in keyof T_28]-?: T_28[K_22] extends infer T_31 ? T_31 extends T_28[K_22] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_21 in keyof T_23]-?: T_23[K_21] extends infer T_28 ? T_28 extends T_23[K_21] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_22 in keyof T_31]-?: T_31[K_22] extends infer T_32 ? T_32 extends T_31[K_22] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_23 in keyof T_30]-?: T_30[K_23] extends infer T_32 ? T_32 extends T_30[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_24 in keyof T_28]-?: T_28[K_24] extends infer T_32 ? T_32 extends T_28[K_24] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_28 : never : never; } : T_23 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_18 in keyof T_17]-?: T_17[K_18] extends infer T_23 ? T_23 extends T_17[K_18] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_11}`, K_18, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_18, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_11}`, K_18, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_18, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_11}`, K_18, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_18, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_11}`, K_18, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_18, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_11}`, K_18, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_18, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_11}`, K_18, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_18, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_11}`, K_18, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_18, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_11}`, K_18, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_18, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_19 in keyof T_28]-?: any; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_20 in keyof T_27]-?: T_27[K_20] extends infer T_29 ? T_29 extends T_27[K_20] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_21 in keyof T_29]-?: T_29[K_21] extends infer T_30 ? T_30 extends T_29[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_21 in keyof T_26]-?: T_26[K_21] extends infer T_29 ? T_29 extends T_26[K_21] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_21, "."> extends infer T_30 ? T_30 extends PrefixWith, K_21, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_21, "."> extends infer T_30 ? T_30 extends PrefixWith, K_21, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_22 in keyof T_31]-?: T_31[K_22] extends infer T_32 ? T_32 extends T_31[K_22] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_23 in keyof T_29]-?: T_29[K_23] extends infer T_32 ? T_32 extends T_29[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_22 in keyof T_25]-?: T_25[K_22] extends infer T_29 ? T_29 extends T_25[K_22] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_23 in keyof T_32]-?: T_32[K_23] extends infer T_33 ? T_33 extends T_32[K_23] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_24 in keyof T_31]-?: T_31[K_24] extends infer T_33 ? T_33 extends T_31[K_24] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_25 in keyof T_29]-?: T_29[K_25] extends infer T_33 ? T_33 extends T_29[K_25] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_23 in keyof T_23]-?: T_23[K_23] extends infer T_29 ? T_29 extends T_23[K_23] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_24 in keyof T_33]-?: T_33[K_24] extends infer T_34 ? T_34 extends T_33[K_24] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_25 in keyof T_32]-?: T_32[K_25] extends infer T_34 ? T_34 extends T_32[K_25] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_26 in keyof T_31]-?: T_31[K_26] extends infer T_34 ? T_34 extends T_31[K_26] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_27 in keyof T_29]-?: T_29[K_27] extends infer T_34 ? T_34 extends T_29[K_27] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_29 : never : never; } : T_23 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_19 in keyof T_16]-?: T_16[K_19] extends infer T_23 ? T_23 extends T_16[K_19] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_20 in keyof T_29]-?: any; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_21 in keyof T_28]-?: T_28[K_21] extends infer T_30 ? T_30 extends T_28[K_21] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_22 in keyof T_30]-?: T_30[K_22] extends infer T_31 ? T_31 extends T_30[K_22] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_22 in keyof T_27]-?: T_27[K_22] extends infer T_30 ? T_30 extends T_27[K_22] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_22, "."> extends infer T_31 ? T_31 extends PrefixWith, K_22, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_22, "."> extends infer T_31 ? T_31 extends PrefixWith, K_22, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_23 in keyof T_32]-?: T_32[K_23] extends infer T_33 ? T_33 extends T_32[K_23] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_24 in keyof T_30]-?: T_30[K_24] extends infer T_33 ? T_33 extends T_30[K_24] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_23 in keyof T_26]-?: T_26[K_23] extends infer T_30 ? T_30 extends T_26[K_23] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_23, "."> extends infer T_31 ? T_31 extends PrefixWith, K_23, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_23, "."> extends infer T_31 ? T_31 extends PrefixWith, K_23, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_23, "."> extends infer T_31 ? T_31 extends PrefixWith, K_23, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_23, "."> extends infer T_31 ? T_31 extends PrefixWith, K_23, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_24 in keyof T_33]-?: T_33[K_24] extends infer T_34 ? T_34 extends T_33[K_24] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_25 in keyof T_32]-?: T_32[K_25] extends infer T_34 ? T_34 extends T_32[K_25] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_26 in keyof T_30]-?: T_30[K_26] extends infer T_34 ? T_34 extends T_30[K_26] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_30 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_24 in keyof T_25]-?: T_25[K_24] extends infer T_30 ? T_30 extends T_25[K_24] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_25 in keyof T_34]-?: T_34[K_25] extends infer T_35 ? T_35 extends T_34[K_25] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_26 in keyof T_33]-?: T_33[K_26] extends infer T_35 ? T_35 extends T_33[K_26] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_27 in keyof T_32]-?: T_32[K_27] extends infer T_35 ? T_35 extends T_32[K_27] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_28 in keyof T_30]-?: T_30[K_28] extends infer T_35 ? T_35 extends T_30[K_28] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_30 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_25 in keyof T_23]-?: T_23[K_25] extends infer T_30 ? T_30 extends T_23[K_25] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_26 in keyof T_35]-?: T_35[K_26] extends infer T_36 ? T_36 extends T_35[K_26] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_27 in keyof T_34]-?: T_34[K_27] extends infer T_36 ? T_36 extends T_34[K_27] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_28 in keyof T_33]-?: T_33[K_28] extends infer T_36 ? T_36 extends T_33[K_28] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_29 in keyof T_32]-?: T_32[K_29] extends infer T_36 ? T_36 extends T_32[K_29] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_30 in keyof T_30]-?: T_30[K_30] extends infer T_36 ? T_36 extends T_30[K_30] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_30 : never : never; } : T_23 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_20 in keyof T_15]-?: T_15[K_20] extends infer T_23 ? T_23 extends T_15[K_20] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_21 in keyof T_30]-?: any; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_22 in keyof T_29]-?: T_29[K_22] extends infer T_31 ? T_31 extends T_29[K_22] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_23 in keyof T_31]-?: T_31[K_23] extends infer T_32 ? T_32 extends T_31[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_23 in keyof T_28]-?: T_28[K_23] extends infer T_31 ? T_31 extends T_28[K_23] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_23, "."> extends infer T_32 ? T_32 extends PrefixWith, K_23, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_23, "."> extends infer T_32 ? T_32 extends PrefixWith, K_23, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_24 in keyof T_33]-?: T_33[K_24] extends infer T_34 ? T_34 extends T_33[K_24] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_25 in keyof T_31]-?: T_31[K_25] extends infer T_34 ? T_34 extends T_31[K_25] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_24 in keyof T_27]-?: T_27[K_24] extends infer T_31 ? T_31 extends T_27[K_24] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_24, "."> extends infer T_32 ? T_32 extends PrefixWith, K_24, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_24, "."> extends infer T_32 ? T_32 extends PrefixWith, K_24, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_24, "."> extends infer T_32 ? T_32 extends PrefixWith, K_24, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_24, "."> extends infer T_32 ? T_32 extends PrefixWith, K_24, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_25 in keyof T_34]-?: T_34[K_25] extends infer T_35 ? T_35 extends T_34[K_25] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_26 in keyof T_33]-?: T_33[K_26] extends infer T_35 ? T_35 extends T_33[K_26] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_27 in keyof T_31]-?: T_31[K_27] extends infer T_35 ? T_35 extends T_31[K_27] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_25 in keyof T_26]-?: T_26[K_25] extends infer T_31 ? T_31 extends T_26[K_25] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_26 in keyof T_35]-?: T_35[K_26] extends infer T_36 ? T_36 extends T_35[K_26] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_27 in keyof T_34]-?: T_34[K_27] extends infer T_36 ? T_36 extends T_34[K_27] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_28 in keyof T_33]-?: T_33[K_28] extends infer T_36 ? T_36 extends T_33[K_28] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_29 in keyof T_31]-?: T_31[K_29] extends infer T_36 ? T_36 extends T_31[K_29] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_31 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_26 in keyof T_25]-?: T_25[K_26] extends infer T_31 ? T_31 extends T_25[K_26] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_27 in keyof T_36]-?: T_36[K_27] extends infer T_37 ? T_37 extends T_36[K_27] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_28 in keyof T_35]-?: T_35[K_28] extends infer T_37 ? T_37 extends T_35[K_28] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_29 in keyof T_34]-?: T_34[K_29] extends infer T_37 ? T_37 extends T_34[K_29] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_30 in keyof T_33]-?: T_33[K_30] extends infer T_37 ? T_37 extends T_33[K_30] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_31 in keyof T_31]-?: T_31[K_31] extends infer T_37 ? T_37 extends T_31[K_31] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_31 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_27 in keyof T_23]-?: T_23[K_27] extends infer T_31 ? T_31 extends T_23[K_27] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_28 in keyof T_37]-?: T_37[K_28] extends infer T_38 ? T_38 extends T_37[K_28] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_29 in keyof T_36]-?: T_36[K_29] extends infer T_38 ? T_38 extends T_36[K_29] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_30 in keyof T_35]-?: T_35[K_30] extends infer T_38 ? T_38 extends T_35[K_30] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_31 in keyof T_34]-?: T_34[K_31] extends infer T_38 ? T_38 extends T_34[K_31] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_32 in keyof T_33]-?: T_33[K_32] extends infer T_38 ? T_38 extends T_33[K_32] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_33 in keyof T_31]-?: T_31[K_33] extends infer T_38 ? T_38 extends T_31[K_33] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_31 : never : never; } : T_23 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_21 in keyof T_14]-?: T_14[K_21] extends infer T_23 ? T_23 extends T_14[K_21] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_22 in keyof T_31]-?: any; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_23 in keyof T_30]-?: T_30[K_23] extends infer T_32 ? T_32 extends T_30[K_23] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_24 in keyof T_32]-?: T_32[K_24] extends infer T_33 ? T_33 extends T_32[K_24] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_24 in keyof T_29]-?: T_29[K_24] extends infer T_32 ? T_32 extends T_29[K_24] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_24, "."> extends infer T_33 ? T_33 extends PrefixWith, K_24, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_24, "."> extends infer T_33 ? T_33 extends PrefixWith, K_24, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_25 in keyof T_34]-?: T_34[K_25] extends infer T_35 ? T_35 extends T_34[K_25] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_26 in keyof T_32]-?: T_32[K_26] extends infer T_35 ? T_35 extends T_32[K_26] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_25 in keyof T_28]-?: T_28[K_25] extends infer T_32 ? T_32 extends T_28[K_25] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_25, "."> extends infer T_33 ? T_33 extends PrefixWith, K_25, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_25, "."> extends infer T_33 ? T_33 extends PrefixWith, K_25, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_25, "."> extends infer T_33 ? T_33 extends PrefixWith, K_25, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_25, "."> extends infer T_33 ? T_33 extends PrefixWith, K_25, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_26 in keyof T_35]-?: T_35[K_26] extends infer T_36 ? T_36 extends T_35[K_26] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_27 in keyof T_34]-?: T_34[K_27] extends infer T_36 ? T_36 extends T_34[K_27] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_28 in keyof T_32]-?: T_32[K_28] extends infer T_36 ? T_36 extends T_32[K_28] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_26 in keyof T_27]-?: T_27[K_26] extends infer T_32 ? T_32 extends T_27[K_26] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_26, "."> extends infer T_33 ? T_33 extends PrefixWith, K_26, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_26, "."> extends infer T_33 ? T_33 extends PrefixWith, K_26, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_26, "."> extends infer T_33 ? T_33 extends PrefixWith, K_26, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_26, "."> extends infer T_33 ? T_33 extends PrefixWith, K_26, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_26, "."> extends infer T_33 ? T_33 extends PrefixWith, K_26, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_26, "."> extends infer T_33 ? T_33 extends PrefixWith, K_26, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_27 in keyof T_36]-?: T_36[K_27] extends infer T_37 ? T_37 extends T_36[K_27] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_28 in keyof T_35]-?: T_35[K_28] extends infer T_37 ? T_37 extends T_35[K_28] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_29 in keyof T_34]-?: T_34[K_29] extends infer T_37 ? T_37 extends T_34[K_29] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_30 in keyof T_32]-?: T_32[K_30] extends infer T_37 ? T_37 extends T_32[K_30] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_32 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_27 in keyof T_26]-?: T_26[K_27] extends infer T_32 ? T_32 extends T_26[K_27] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_27, "."> extends infer T_33 ? T_33 extends PrefixWith, K_27, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_27, "."> extends infer T_33 ? T_33 extends PrefixWith, K_27, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_27, "."> extends infer T_33 ? T_33 extends PrefixWith, K_27, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_27, "."> extends infer T_33 ? T_33 extends PrefixWith, K_27, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_27, "."> extends infer T_33 ? T_33 extends PrefixWith, K_27, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_27, "."> extends infer T_33 ? T_33 extends PrefixWith, K_27, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_27, "."> extends infer T_33 ? T_33 extends PrefixWith, K_27, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_27, "."> extends infer T_33 ? T_33 extends PrefixWith, K_27, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_28 in keyof T_37]-?: T_37[K_28] extends infer T_38 ? T_38 extends T_37[K_28] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_29 in keyof T_36]-?: T_36[K_29] extends infer T_38 ? T_38 extends T_36[K_29] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_30 in keyof T_35]-?: T_35[K_30] extends infer T_38 ? T_38 extends T_35[K_30] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_31 in keyof T_34]-?: T_34[K_31] extends infer T_38 ? T_38 extends T_34[K_31] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_32 in keyof T_32]-?: T_32[K_32] extends infer T_38 ? T_38 extends T_32[K_32] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_32 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_28 in keyof T_25]-?: T_25[K_28] extends infer T_32 ? T_32 extends T_25[K_28] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? any : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_29 in keyof T_38]-?: T_38[K_29] extends infer T_39 ? T_39 extends T_38[K_29] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_30 in keyof T_37]-?: T_37[K_30] extends infer T_39 ? T_39 extends T_37[K_30] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_31 in keyof T_36]-?: T_36[K_31] extends infer T_39 ? T_39 extends T_36[K_31] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_32 in keyof T_35]-?: T_35[K_32] extends infer T_39 ? T_39 extends T_35[K_32] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_33 in keyof T_34]-?: T_34[K_33] extends infer T_39 ? T_39 extends T_34[K_33] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_34 in keyof T_32]-?: T_32[K_34] extends infer T_39 ? T_39 extends T_32[K_34] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_32 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_29 in keyof T_23]-?: T_23[K_29] extends infer T_32 ? T_32 extends T_23[K_29] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? any : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_30 in keyof T_39]-?: T_39[K_30] extends infer T_40 ? T_40 extends T_39[K_30] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_31 in keyof T_38]-?: T_38[K_31] extends infer T_40 ? T_40 extends T_38[K_31] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_32 in keyof T_37]-?: T_37[K_32] extends infer T_40 ? T_40 extends T_37[K_32] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_33 in keyof T_36]-?: T_36[K_33] extends infer T_40 ? T_40 extends T_36[K_33] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_34 in keyof T_35]-?: T_35[K_34] extends infer T_40 ? T_40 extends T_35[K_34] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_35 in keyof T_34]-?: T_34[K_35] extends infer T_40 ? T_40 extends T_34[K_35] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_36 in keyof T_32]-?: T_32[K_36] extends infer T_40 ? T_40 extends T_32[K_36] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_32 : never : never; } : T_23 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_22 in keyof T_12]-?: T_12[K_22] extends infer T_23 ? T_23 extends T_12[K_22] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_23 in keyof T_32]-?: any; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_24 in keyof T_31]-?: T_31[K_24] extends infer T_33 ? T_33 extends T_31[K_24] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_25 in keyof T_33]-?: T_33[K_25] extends infer T_34 ? T_34 extends T_33[K_25] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_25 in keyof T_30]-?: T_30[K_25] extends infer T_33 ? T_33 extends T_30[K_25] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_25, "."> extends infer T_34 ? T_34 extends PrefixWith, K_25, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_25, "."> extends infer T_34 ? T_34 extends PrefixWith, K_25, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_26 in keyof T_35]-?: T_35[K_26] extends infer T_36 ? T_36 extends T_35[K_26] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_27 in keyof T_33]-?: T_33[K_27] extends infer T_36 ? T_36 extends T_33[K_27] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_26 in keyof T_29]-?: T_29[K_26] extends infer T_33 ? T_33 extends T_29[K_26] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_26, "."> extends infer T_34 ? T_34 extends PrefixWith, K_26, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_26, "."> extends infer T_34 ? T_34 extends PrefixWith, K_26, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_26, "."> extends infer T_34 ? T_34 extends PrefixWith, K_26, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_26, "."> extends infer T_34 ? T_34 extends PrefixWith, K_26, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_27 in keyof T_36]-?: T_36[K_27] extends infer T_37 ? T_37 extends T_36[K_27] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_28 in keyof T_35]-?: T_35[K_28] extends infer T_37 ? T_37 extends T_35[K_28] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_29 in keyof T_33]-?: T_33[K_29] extends infer T_37 ? T_37 extends T_33[K_29] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_27 in keyof T_28]-?: T_28[K_27] extends infer T_33 ? T_33 extends T_28[K_27] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_27, "."> extends infer T_34 ? T_34 extends PrefixWith, K_27, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_27, "."> extends infer T_34 ? T_34 extends PrefixWith, K_27, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_27, "."> extends infer T_34 ? T_34 extends PrefixWith, K_27, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_27, "."> extends infer T_34 ? T_34 extends PrefixWith, K_27, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_27, "."> extends infer T_34 ? T_34 extends PrefixWith, K_27, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_27, "."> extends infer T_34 ? T_34 extends PrefixWith, K_27, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_28 in keyof T_37]-?: T_37[K_28] extends infer T_38 ? T_38 extends T_37[K_28] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_29 in keyof T_36]-?: T_36[K_29] extends infer T_38 ? T_38 extends T_36[K_29] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_30 in keyof T_35]-?: T_35[K_30] extends infer T_38 ? T_38 extends T_35[K_30] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_31 in keyof T_33]-?: T_33[K_31] extends infer T_38 ? T_38 extends T_33[K_31] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_33 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_28 in keyof T_27]-?: T_27[K_28] extends infer T_33 ? T_33 extends T_27[K_28] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_28, "."> extends infer T_34 ? T_34 extends PrefixWith, K_28, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_28, "."> extends infer T_34 ? T_34 extends PrefixWith, K_28, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_28, "."> extends infer T_34 ? T_34 extends PrefixWith, K_28, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_28, "."> extends infer T_34 ? T_34 extends PrefixWith, K_28, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_28, "."> extends infer T_34 ? T_34 extends PrefixWith, K_28, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_28, "."> extends infer T_34 ? T_34 extends PrefixWith, K_28, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_28, "."> extends infer T_34 ? T_34 extends PrefixWith, K_28, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_28, "."> extends infer T_34 ? T_34 extends PrefixWith, K_28, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? any : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_29 in keyof T_38]-?: T_38[K_29] extends infer T_39 ? T_39 extends T_38[K_29] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_30 in keyof T_37]-?: T_37[K_30] extends infer T_39 ? T_39 extends T_37[K_30] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_31 in keyof T_36]-?: T_36[K_31] extends infer T_39 ? T_39 extends T_36[K_31] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_32 in keyof T_35]-?: T_35[K_32] extends infer T_39 ? T_39 extends T_35[K_32] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_33 in keyof T_33]-?: T_33[K_33] extends infer T_39 ? T_39 extends T_33[K_33] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_33 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_29 in keyof T_26]-?: T_26[K_29] extends infer T_33 ? T_33 extends T_26[K_29] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? any : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_30 in keyof T_39]-?: T_39[K_30] extends infer T_40 ? T_40 extends T_39[K_30] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_31 in keyof T_38]-?: T_38[K_31] extends infer T_40 ? T_40 extends T_38[K_31] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_32 in keyof T_37]-?: T_37[K_32] extends infer T_40 ? T_40 extends T_37[K_32] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_33 in keyof T_36]-?: T_36[K_33] extends infer T_40 ? T_40 extends T_36[K_33] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_34 in keyof T_35]-?: T_35[K_34] extends infer T_40 ? T_40 extends T_35[K_34] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_35 in keyof T_33]-?: T_33[K_35] extends infer T_40 ? T_40 extends T_33[K_35] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_33 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_30 in keyof T_25]-?: T_25[K_30] extends infer T_33 ? T_33 extends T_25[K_30] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? T_39[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_40 ? T_40 extends T_39[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_40 extends CanBeExpanded ? any : T_40 extends (infer U)[] ? any[] : T_40 extends object ? { [K_31 in keyof T_40]-?: T_40[K_31] extends infer T_41 ? T_41 extends T_40[K_31] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_40 : never : never : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_32 in keyof T_39]-?: T_39[K_32] extends infer T_41 ? T_41 extends T_39[K_32] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_33 in keyof T_38]-?: T_38[K_33] extends infer T_41 ? T_41 extends T_38[K_33] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_34 in keyof T_37]-?: T_37[K_34] extends infer T_41 ? T_41 extends T_37[K_34] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_35 in keyof T_36]-?: T_36[K_35] extends infer T_41 ? T_41 extends T_36[K_35] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_36 in keyof T_35]-?: T_35[K_36] extends infer T_41 ? T_41 extends T_35[K_36] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_37 in keyof T_33]-?: T_33[K_37] extends infer T_41 ? T_41 extends T_33[K_37] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_33 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_31 in keyof T_23]-?: T_23[K_31] extends infer T_33 ? T_33 extends T_23[K_31] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? T_39[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_40 ? T_40 extends T_39[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_40 extends CanBeExpanded ? T_40[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_41 ? T_41 extends T_40[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_41 extends CanBeExpanded ? any : T_41 extends (infer U)[] ? any[] : T_41 extends object ? { [K_32 in keyof T_41]-?: T_41[K_32] extends infer T_42 ? T_42 extends T_41[K_32] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_41 : never : never : T_40 extends (infer U)[] ? any[] : T_40 extends object ? { [K_33 in keyof T_40]-?: T_40[K_33] extends infer T_42 ? T_42 extends T_40[K_33] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_40 : never : never : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_34 in keyof T_39]-?: T_39[K_34] extends infer T_42 ? T_42 extends T_39[K_34] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_35 in keyof T_38]-?: T_38[K_35] extends infer T_42 ? T_42 extends T_38[K_35] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_36 in keyof T_37]-?: T_37[K_36] extends infer T_42 ? T_42 extends T_37[K_36] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_37 in keyof T_36]-?: T_36[K_37] extends infer T_42 ? T_42 extends T_36[K_37] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_38 in keyof T_35]-?: T_35[K_38] extends infer T_42 ? T_42 extends T_35[K_38] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_39 in keyof T_33]-?: T_33[K_39] extends infer T_42 ? T_42 extends T_33[K_39] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_33 : never : never; } : T_23 : never : never; } : T_12 : never : never; } : T -+>UseQueryOptions : T extends CanBeExpanded ? T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_2 ? T_2 extends T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_2 extends CanBeExpanded ? T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_3 ? T_3 extends T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_3 extends CanBeExpanded ? T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_1]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: any; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_3 extends (infer U)[] ? any[] : T_3 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? any : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: any; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: any; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_3 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_1]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: any; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? any : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: any; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never : T extends (infer U)[] ? any[] : T extends object ? { [K_1 in keyof T]-?: T[K_1] extends infer T_1 ? T_1 extends T[K_1] ? T_1 extends CanBeExpanded ? T_1[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_3 ? T_3 extends T_1[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_3 extends CanBeExpanded ? T_3[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_3[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_1]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: any; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_3 extends (infer U)[] ? any[] : T_3 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? any : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: any; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_3 : never : never : T_1 extends (infer U)[] ? any[] : T_1 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_1]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? any : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_1 : never : never; } : T ++>UseQueryOptions : T extends CanBeExpanded ? T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_2 ? T_2 extends T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_2 extends CanBeExpanded ? T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_3 ? T_3 extends T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_3 extends CanBeExpanded ? T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_11]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_10]-?: T_10[K_1] extends infer T_12 ? T_12 extends T_10[K_1] ? T_12 extends CanBeExpanded ? any : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: any; } : T_12 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_9]-?: T_9[K_1] extends infer T_12 ? T_12 extends T_9[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? any : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: any; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_15 ? T_15 extends T_12[K_2] ? T_15 extends CanBeExpanded ? any : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_3 in keyof T_15]-?: any; } : T_15 : never : never; } : T_12 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_8]-?: T_8[K_1] extends infer T_12 ? T_12 extends T_8[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? any : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: any; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_16 ? T_16 extends T_14[K_2] ? T_16 extends CanBeExpanded ? any : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_3 in keyof T_16]-?: any; } : T_16 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_16 ? T_16 extends T_12[K_2] ? T_16 extends CanBeExpanded ? T_16[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_17 ? T_17 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_17 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_16[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_17 ? T_17 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_17 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? any : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: any; } : T_18 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_3 in keyof T_16]-?: T_16[K_3] extends infer T_19 ? T_19 extends T_16[K_3] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_4 in keyof T_19]-?: T_19[K_4] extends infer T_20 ? T_20 extends T_19[K_4] ? T_20 extends CanBeExpanded ? T_20["default"] : T_20 : never : never; } : T_19 : never : never; } : T_16 : never : never; } : T_12 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_7]-?: T_7[K_1] extends infer T_12 ? T_12 extends T_7[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? any : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: any; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_17 ? T_17 extends T_15[K_2] ? T_17 extends CanBeExpanded ? any : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_3 in keyof T_17]-?: any; } : T_17 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_17 ? T_17 extends T_14[K_2] ? T_17 extends CanBeExpanded ? T_17[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_17[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: any; } : T_19 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_3 in keyof T_17]-?: T_17[K_3] extends infer T_20 ? T_20 extends T_17[K_3] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_4 in keyof T_20]-?: T_20[K_4] extends infer T_21 ? T_21 extends T_20[K_4] ? T_21 extends CanBeExpanded ? T_21["default"] : T_21 : never : never; } : T_20 : never : never; } : T_17 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_17 ? T_17 extends T_12[K_2] ? T_17 extends CanBeExpanded ? T_17[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_17[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: any; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_21 ? T_21 extends T_19[K_3] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_4 in keyof T_21]-?: T_21[K_4] extends infer T_22 ? T_22 extends T_21[K_4] ? T_22 extends CanBeExpanded ? T_22["default"] : T_22 : never : never; } : T_21 : never : never; } : T_19 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_3 in keyof T_17]-?: T_17[K_3] extends infer T_21 ? T_21 extends T_17[K_3] ? T_21 extends CanBeExpanded ? T_21[PrefixWith, K_3, "."> extends infer T_22 ? T_22 extends PrefixWith, K_3, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith, K_3, "."> extends infer T_22 ? T_22 extends PrefixWith, K_3, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_24 ? T_24 extends T_23[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_4 in keyof T_21]-?: T_21[K_4] extends infer T_24 ? T_24 extends T_21[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_21 : never : never; } : T_17 : never : never; } : T_12 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_6]-?: T_6[K_1] extends infer T_12 ? T_12 extends T_6[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? any : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: any; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_18 ? T_18 extends T_16[K_2] ? T_18 extends CanBeExpanded ? any : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: any; } : T_18 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_18 ? T_18 extends T_15[K_2] ? T_18 extends CanBeExpanded ? T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: any; } : T_20 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: T_18[K_3] extends infer T_21 ? T_21 extends T_18[K_3] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_4 in keyof T_21]-?: T_21[K_4] extends infer T_22 ? T_22 extends T_21[K_4] ? T_22 extends CanBeExpanded ? T_22["default"] : T_22 : never : never; } : T_21 : never : never; } : T_18 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_18 ? T_18 extends T_14[K_2] ? T_18 extends CanBeExpanded ? T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: any; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_22 ? T_22 extends T_20[K_3] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_4 in keyof T_22]-?: T_22[K_4] extends infer T_23 ? T_23 extends T_22[K_4] ? T_23 extends CanBeExpanded ? T_23["default"] : T_23 : never : never; } : T_22 : never : never; } : T_20 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: T_18[K_3] extends infer T_22 ? T_22 extends T_18[K_3] ? T_22 extends CanBeExpanded ? T_22[PrefixWith, K_3, "."> extends infer T_23 ? T_23 extends PrefixWith, K_3, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith, K_3, "."> extends infer T_23 ? T_23 extends PrefixWith, K_3, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_25 ? T_25 extends T_24[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_4 in keyof T_22]-?: T_22[K_4] extends infer T_25 ? T_25 extends T_22[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_22 : never : never; } : T_18 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_18 ? T_18 extends T_12[K_2] ? T_18 extends CanBeExpanded ? T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: any; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_23 ? T_23 extends T_21[K_3] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_24 ? T_24 extends T_23[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_23 ? T_23 extends T_20[K_3] ? T_23 extends CanBeExpanded ? T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_26 ? T_26 extends T_23[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_23 : never : never; } : T_20 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: T_18[K_3] extends infer T_23 ? T_23 extends T_18[K_3] ? T_23 extends CanBeExpanded ? T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_27 ? T_27 extends T_25[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_27 ? T_27 extends T_23[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_23 : never : never; } : T_18 : never : never; } : T_12 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_5]-?: T_5[K_1] extends infer T_12 ? T_12 extends T_5[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? any : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: any; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_19 ? T_19 extends T_17[K_2] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: any; } : T_19 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_19 ? T_19 extends T_16[K_2] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: any; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_22 ? T_22 extends T_19[K_3] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_4 in keyof T_22]-?: T_22[K_4] extends infer T_23 ? T_23 extends T_22[K_4] ? T_23 extends CanBeExpanded ? T_23["default"] : T_23 : never : never; } : T_22 : never : never; } : T_19 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_19 ? T_19 extends T_15[K_2] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: any; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_23 ? T_23 extends T_21[K_3] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_24 ? T_24 extends T_23[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_23 ? T_23 extends T_19[K_3] ? T_23 extends CanBeExpanded ? T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_26 ? T_26 extends T_23[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_23 : never : never; } : T_19 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_19 ? T_19 extends T_14[K_2] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: any; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_24 ? T_24 extends T_22[K_3] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_25 ? T_25 extends T_24[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_24 ? T_24 extends T_21[K_3] ? T_24 extends CanBeExpanded ? T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_27 ? T_27 extends T_24[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_24 : never : never; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_24 ? T_24 extends T_19[K_3] ? T_24 extends CanBeExpanded ? T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_28 ? T_28 extends T_26[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_26 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_28 ? T_28 extends T_24[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_24 : never : never; } : T_19 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_19 ? T_19 extends T_12[K_2] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: any; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_25 ? T_25 extends T_23[K_3] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_25 ? T_25 extends T_22[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_28 ? T_28 extends T_25[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_25 : never : never; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_25 ? T_25 extends T_21[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_29 ? T_29 extends T_27[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_29 ? T_29 extends T_25[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_25 : never : never; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_25 ? T_25 extends T_19[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_30 ? T_30 extends T_28[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_30 ? T_30 extends T_25[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_25 : never : never; } : T_19 : never : never; } : T_12 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_4]-?: T_4[K_1] extends infer T_12 ? T_12 extends T_4[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_2 in keyof T_19]-?: any; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: T_18[K_2] extends infer T_20 ? T_20 extends T_18[K_2] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: any; } : T_20 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_20 ? T_20 extends T_17[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: any; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_23 ? T_23 extends T_20[K_3] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_24 ? T_24 extends T_23[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never; } : T_20 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_20 ? T_20 extends T_16[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: any; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_24 ? T_24 extends T_22[K_3] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_25 ? T_25 extends T_24[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_24 ? T_24 extends T_20[K_3] ? T_24 extends CanBeExpanded ? T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_27 ? T_27 extends T_24[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_24 : never : never; } : T_20 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_20 ? T_20 extends T_15[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: any; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_25 ? T_25 extends T_23[K_3] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_25 ? T_25 extends T_22[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_28 ? T_28 extends T_25[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_25 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_25 ? T_25 extends T_20[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_29 ? T_29 extends T_27[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_29 ? T_29 extends T_25[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_25 : never : never; } : T_20 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_20 ? T_20 extends T_14[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: any; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_26 ? T_26 extends T_24[K_3] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_26 ? T_26 extends T_23[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_29 ? T_29 extends T_26[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_26 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_26 ? T_26 extends T_22[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_30 ? T_30 extends T_28[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_30 ? T_30 extends T_26[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_26 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_26 ? T_26 extends T_20[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_31 ? T_31 extends T_29[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_31 ? T_31 extends T_28[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_31 ? T_31 extends T_26[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_26 : never : never; } : T_20 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_20 ? T_20 extends T_12[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_27 ? T_27 extends T_25[K_3] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_27 ? T_27 extends T_24[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_27 ? T_27 extends T_23[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_31 ? T_31 extends T_29[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_31 ? T_31 extends T_27[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_27 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_27 ? T_27 extends T_22[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_32 ? T_32 extends T_27[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_27 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_27 ? T_27 extends T_20[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_33 ? T_33 extends T_29[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_33 ? T_33 extends T_27[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_27 : never : never; } : T_20 : never : never; } : T_12 : never : never; } : T_4 : never : never : T_3 extends (infer U)[] ? any[] : T_3 extends object ? { [K_1 in keyof T_3]-?: T_3[K_1] extends infer T_12 ? T_12 extends T_3[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_2 in keyof T_20]-?: any; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_2 in keyof T_19]-?: T_19[K_2] extends infer T_21 ? T_21 extends T_19[K_2] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: any; } : T_21 : never : never; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: T_18[K_2] extends infer T_21 ? T_21 extends T_18[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: any; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_24 ? T_24 extends T_21[K_3] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_25 ? T_25 extends T_24[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never; } : T_21 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_21 ? T_21 extends T_17[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: any; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_25 ? T_25 extends T_23[K_3] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_25 ? T_25 extends T_21[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_28 ? T_28 extends T_25[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_25 : never : never; } : T_21 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_21 ? T_21 extends T_16[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: any; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_26 ? T_26 extends T_24[K_3] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_26 ? T_26 extends T_23[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_29 ? T_29 extends T_26[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_26 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_26 ? T_26 extends T_21[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_30 ? T_30 extends T_28[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_30 ? T_30 extends T_26[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_26 : never : never; } : T_21 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_21 ? T_21 extends T_15[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_27 ? T_27 extends T_25[K_3] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_27 ? T_27 extends T_24[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_27 ? T_27 extends T_23[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_31 ? T_31 extends T_29[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_31 ? T_31 extends T_27[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_27 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_27 ? T_27 extends T_21[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_32 ? T_32 extends T_27[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_27 : never : never; } : T_21 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_21 ? T_21 extends T_14[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: any; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_28 ? T_28 extends T_26[K_3] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_28 ? T_28 extends T_25[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_31 ? T_31 extends T_28[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_28 ? T_28 extends T_24[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_32 ? T_32 extends T_28[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_28 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_28 ? T_28 extends T_23[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_33 ? T_33 extends T_28[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_28 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_28 ? T_28 extends T_21[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_34 ? T_34 extends T_30[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_34 ? T_34 extends T_28[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_28 : never : never; } : T_21 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_21 ? T_21 extends T_12[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: any; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_29 ? T_29 extends T_27[K_3] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_29 ? T_29 extends T_26[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_29 ? T_29 extends T_25[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_33 ? T_33 extends T_29[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_29 ? T_29 extends T_24[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_34 ? T_34 extends T_29[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_29 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_29 ? T_29 extends T_23[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_35 ? T_35 extends T_31[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_35 ? T_35 extends T_29[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_29 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_29 ? T_29 extends T_21[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_36 ? T_36 extends T_32[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_36 ? T_36 extends T_31[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_36 ? T_36 extends T_29[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_29 : never : never; } : T_21 : never : never; } : T_12 : never : never; } : T_3 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_2]-?: T_2[K_1] extends infer T_12 ? T_12 extends T_2[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_2 in keyof T_21]-?: any; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_2 in keyof T_20]-?: T_20[K_2] extends infer T_22 ? T_22 extends T_20[K_2] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: any; } : T_22 : never : never; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_2 in keyof T_19]-?: T_19[K_2] extends infer T_22 ? T_22 extends T_19[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: any; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_25 ? T_25 extends T_22[K_3] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_22 : never : never; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: T_18[K_2] extends infer T_22 ? T_22 extends T_18[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: any; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_26 ? T_26 extends T_24[K_3] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_26 ? T_26 extends T_22[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_29 ? T_29 extends T_26[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_26 : never : never; } : T_22 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_22 ? T_22 extends T_17[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_27 ? T_27 extends T_25[K_3] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_27 ? T_27 extends T_24[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_27 ? T_27 extends T_22[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_31 ? T_31 extends T_29[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_31 ? T_31 extends T_27[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_27 : never : never; } : T_22 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_22 ? T_22 extends T_16[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: any; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_28 ? T_28 extends T_26[K_3] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_28 ? T_28 extends T_25[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_31 ? T_31 extends T_28[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_28 ? T_28 extends T_24[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_32 ? T_32 extends T_28[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_28 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_28 ? T_28 extends T_22[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_33 ? T_33 extends T_28[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_28 : never : never; } : T_22 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_22 ? T_22 extends T_15[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: any; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_29 ? T_29 extends T_27[K_3] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_29 ? T_29 extends T_26[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_29 ? T_29 extends T_25[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_33 ? T_33 extends T_29[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_29 ? T_29 extends T_24[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_34 ? T_34 extends T_29[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_29 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_29 ? T_29 extends T_22[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_35 ? T_35 extends T_31[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_35 ? T_35 extends T_29[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_29 : never : never; } : T_22 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_22 ? T_22 extends T_14[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: any; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_30 ? T_30 extends T_28[K_3] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_30 ? T_30 extends T_27[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_30 ? T_30 extends T_26[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_34 ? T_34 extends T_30[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_30 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_30 ? T_30 extends T_25[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_35 ? T_35 extends T_30[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_30 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_30 ? T_30 extends T_24[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_36 ? T_36 extends T_32[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_36 ? T_36 extends T_30[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_30 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_30 ? T_30 extends T_22[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_37 ? T_37 extends T_34[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_37 ? T_37 extends T_33[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_37 ? T_37 extends T_32[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_37 ? T_37 extends T_30[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_30 : never : never; } : T_22 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_22 ? T_22 extends T_12[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_3 in keyof T_30]-?: any; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: T_29[K_3] extends infer T_31 ? T_31 extends T_29[K_3] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_31 ? T_31 extends T_28[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_31 ? T_31 extends T_27[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_35 ? T_35 extends T_31[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_31 ? T_31 extends T_26[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_36 ? T_36 extends T_31[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_31 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_31 ? T_31 extends T_25[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_37 ? T_37 extends T_34[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_37 ? T_37 extends T_33[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_37 ? T_37 extends T_31[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_31 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_31 ? T_31 extends T_24[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_38 ? T_38 extends T_37[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_38 ? T_38 extends T_36[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_38 ? T_38 extends T_35[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_38 ? T_38 extends T_34[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_38 ? T_38 extends T_33[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_38 ? T_38 extends T_31[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_31 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_31 ? T_31 extends T_22[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? any : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_39 ? T_39 extends T_38[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_39 ? T_39 extends T_37[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_39 ? T_39 extends T_36[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_39 ? T_39 extends T_35[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_39 ? T_39 extends T_34[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_39 ? T_39 extends T_33[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_39 ? T_39 extends T_31[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_31 : never : never; } : T_22 : never : never; } : T_12 : never : never; } : T_2 : never : never : T extends (infer U)[] ? any[] : T extends object ? { [K_1 in keyof T]-?: T[K_1] extends infer T_12 ? T_12 extends T[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_2 in keyof T_22]-?: any; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_2 in keyof T_21]-?: T_21[K_2] extends infer T_23 ? T_23 extends T_21[K_2] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: any; } : T_23 : never : never; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_2 in keyof T_20]-?: T_20[K_2] extends infer T_23 ? T_23 extends T_20[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: any; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_26 ? T_26 extends T_23[K_3] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_23 : never : never; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_2 in keyof T_19]-?: T_19[K_2] extends infer T_23 ? T_23 extends T_19[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_27 ? T_27 extends T_25[K_3] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_27 ? T_27 extends T_23[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_23 : never : never; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: T_18[K_2] extends infer T_23 ? T_23 extends T_18[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: any; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_28 ? T_28 extends T_26[K_3] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_28 ? T_28 extends T_25[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_31 ? T_31 extends T_28[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_28 ? T_28 extends T_23[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_32 ? T_32 extends T_28[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_28 : never : never; } : T_23 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_23 ? T_23 extends T_17[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: any; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_29 ? T_29 extends T_27[K_3] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_29 ? T_29 extends T_26[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_29 ? T_29 extends T_25[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_33 ? T_33 extends T_29[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_29 ? T_29 extends T_23[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_34 ? T_34 extends T_29[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_29 : never : never; } : T_23 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_23 ? T_23 extends T_16[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: any; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_30 ? T_30 extends T_28[K_3] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_30 ? T_30 extends T_27[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_30 ? T_30 extends T_26[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_34 ? T_34 extends T_30[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_30 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_30 ? T_30 extends T_25[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_35 ? T_35 extends T_30[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_30 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_30 ? T_30 extends T_23[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_36 ? T_36 extends T_32[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_36 ? T_36 extends T_30[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_30 : never : never; } : T_23 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_23 ? T_23 extends T_15[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_3 in keyof T_30]-?: any; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: T_29[K_3] extends infer T_31 ? T_31 extends T_29[K_3] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_31 ? T_31 extends T_28[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_31 ? T_31 extends T_27[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_35 ? T_35 extends T_31[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_31 ? T_31 extends T_26[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_36 ? T_36 extends T_31[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_31 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_31 ? T_31 extends T_25[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_37 ? T_37 extends T_34[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_37 ? T_37 extends T_33[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_37 ? T_37 extends T_31[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_31 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_31 ? T_31 extends T_23[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_38 ? T_38 extends T_37[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_38 ? T_38 extends T_36[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_38 ? T_38 extends T_35[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_38 ? T_38 extends T_34[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_38 ? T_38 extends T_33[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_38 ? T_38 extends T_31[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_31 : never : never; } : T_23 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_23 ? T_23 extends T_14[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_3 in keyof T_31]-?: any; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_3 in keyof T_30]-?: T_30[K_3] extends infer T_32 ? T_32 extends T_30[K_3] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: T_29[K_3] extends infer T_32 ? T_32 extends T_29[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_32 ? T_32 extends T_28[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_36 ? T_36 extends T_32[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_32 ? T_32 extends T_27[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_37 ? T_37 extends T_34[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_37 ? T_37 extends T_32[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_32 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_32 ? T_32 extends T_26[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_38 ? T_38 extends T_37[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_38 ? T_38 extends T_36[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_38 ? T_38 extends T_35[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_38 ? T_38 extends T_34[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_38 ? T_38 extends T_32[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_32 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_32 ? T_32 extends T_25[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? any : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_39 ? T_39 extends T_38[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_39 ? T_39 extends T_37[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_39 ? T_39 extends T_36[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_39 ? T_39 extends T_35[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_39 ? T_39 extends T_34[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_39 ? T_39 extends T_32[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_32 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_32 ? T_32 extends T_23[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? any : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_4 in keyof T_39]-?: T_39[K_4] extends infer T_40 ? T_40 extends T_39[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_40 ? T_40 extends T_38[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_40 ? T_40 extends T_37[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_40 ? T_40 extends T_36[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_40 ? T_40 extends T_35[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_40 ? T_40 extends T_34[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_40 ? T_40 extends T_32[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_32 : never : never; } : T_23 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_23 ? T_23 extends T_12[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_3 in keyof T_32]-?: any; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_3 in keyof T_31]-?: T_31[K_3] extends infer T_33 ? T_33 extends T_31[K_3] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_3 in keyof T_30]-?: T_30[K_3] extends infer T_33 ? T_33 extends T_30[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: T_29[K_3] extends infer T_33 ? T_33 extends T_29[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_37 ? T_37 extends T_33[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_33 ? T_33 extends T_28[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_38 ? T_38 extends T_37[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_38 ? T_38 extends T_36[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_38 ? T_38 extends T_35[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_38 ? T_38 extends T_33[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_33 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_33 ? T_33 extends T_27[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? any : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_39 ? T_39 extends T_38[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_39 ? T_39 extends T_37[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_39 ? T_39 extends T_36[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_39 ? T_39 extends T_35[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_39 ? T_39 extends T_33[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_33 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_33 ? T_33 extends T_26[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? any : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_4 in keyof T_39]-?: T_39[K_4] extends infer T_40 ? T_40 extends T_39[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_40 ? T_40 extends T_38[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_40 ? T_40 extends T_37[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_40 ? T_40 extends T_36[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_40 ? T_40 extends T_35[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_40 ? T_40 extends T_33[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_33 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_33 ? T_33 extends T_25[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? T_39[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_40 ? T_40 extends T_39[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_40 extends CanBeExpanded ? any : T_40 extends (infer U)[] ? any[] : T_40 extends object ? { [K_4 in keyof T_40]-?: T_40[K_4] extends infer T_41 ? T_41 extends T_40[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_40 : never : never : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_4 in keyof T_39]-?: T_39[K_4] extends infer T_41 ? T_41 extends T_39[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_41 ? T_41 extends T_38[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_41 ? T_41 extends T_37[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_41 ? T_41 extends T_36[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_41 ? T_41 extends T_35[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_41 ? T_41 extends T_33[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_33 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_33 ? T_33 extends T_23[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? T_39[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_40 ? T_40 extends T_39[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_40 extends CanBeExpanded ? T_40[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_41 ? T_41 extends T_40[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_41 extends CanBeExpanded ? any : T_41 extends (infer U)[] ? any[] : T_41 extends object ? { [K_4 in keyof T_41]-?: T_41[K_4] extends infer T_42 ? T_42 extends T_41[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_41 : never : never : T_40 extends (infer U)[] ? any[] : T_40 extends object ? { [K_4 in keyof T_40]-?: T_40[K_4] extends infer T_42 ? T_42 extends T_40[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_40 : never : never : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_4 in keyof T_39]-?: T_39[K_4] extends infer T_42 ? T_42 extends T_39[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_42 ? T_42 extends T_38[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_42 ? T_42 extends T_37[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_42 ? T_42 extends T_36[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_42 ? T_42 extends T_35[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_42 ? T_42 extends T_33[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_33 : never : never; } : T_23 : never : never; } : T_12 : never : never; } : T type UseQueryOptions2 = Expand_ ->UseQueryOptions2 : T extends CanBeExpanded ? T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_2 ? T_2 extends T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_2 extends CanBeExpanded ? T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_3 ? T_3 extends T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_3 extends CanBeExpanded ? T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_11]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_2 in keyof T_10]-?: T_10[K_2] extends infer T_12 ? T_12 extends T_10[K_2] ? T_12 extends CanBeExpanded ? any : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_4 in keyof T_12]-?: any; } : T_12 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_3 in keyof T_9]-?: T_9[K_3] extends infer T_12 ? T_12 extends T_9[K_3] ? T_12 extends CanBeExpanded ? T_12[`${string & K_3}` extends infer T_13 ? T_13 extends `${string & K_3}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_3}` extends infer T_13 ? T_13 extends `${string & K_3}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? any : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_5 in keyof T_14]-?: any; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_6 in keyof T_12]-?: T_12[K_6] extends infer T_15 ? T_15 extends T_12[K_6] ? T_15 extends CanBeExpanded ? any : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_7 in keyof T_15]-?: any; } : T_15 : never : never; } : T_12 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_4 in keyof T_8]-?: T_8[K_4] extends infer T_12 ? T_12 extends T_8[K_4] ? T_12 extends CanBeExpanded ? T_12[`${string & K_4}` extends infer T_13 ? T_13 extends `${string & K_4}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_4}` extends infer T_13 ? T_13 extends `${string & K_4}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_4}` extends infer T_13 ? T_13 extends `${string & K_4}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_4}` extends infer T_13 ? T_13 extends `${string & K_4}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? any : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_6 in keyof T_15]-?: any; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_7 in keyof T_14]-?: T_14[K_7] extends infer T_16 ? T_16 extends T_14[K_7] ? T_16 extends CanBeExpanded ? any : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_8 in keyof T_16]-?: any; } : T_16 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_8 in keyof T_12]-?: T_12[K_8] extends infer T_16 ? T_16 extends T_12[K_8] ? T_16 extends CanBeExpanded ? T_16[PrefixWith<`${string & K_4}`, K_8, "."> extends infer T_17 ? T_17 extends PrefixWith<`${string & K_4}`, K_8, "."> ? T_17 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_16[PrefixWith<`${string & K_4}`, K_8, "."> extends infer T_17 ? T_17 extends PrefixWith<`${string & K_4}`, K_8, "."> ? T_17 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? any : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_9 in keyof T_18]-?: any; } : T_18 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_10 in keyof T_16]-?: T_16[K_10] extends infer T_19 ? T_19 extends T_16[K_10] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_11 in keyof T_19]-?: T_19[K_11] extends infer T_20 ? T_20 extends T_19[K_11] ? T_20 extends CanBeExpanded ? T_20["default"] : T_20 : never : never; } : T_19 : never : never; } : T_16 : never : never; } : T_12 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_5 in keyof T_7]-?: T_7[K_5] extends infer T_12 ? T_12 extends T_7[K_5] ? T_12 extends CanBeExpanded ? T_12[`${string & K_5}` extends infer T_13 ? T_13 extends `${string & K_5}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_5}` extends infer T_13 ? T_13 extends `${string & K_5}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_5}` extends infer T_13 ? T_13 extends `${string & K_5}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_5}` extends infer T_13 ? T_13 extends `${string & K_5}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_5}` extends infer T_13 ? T_13 extends `${string & K_5}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_5}` extends infer T_13 ? T_13 extends `${string & K_5}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? any : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_7 in keyof T_16]-?: any; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_8 in keyof T_15]-?: T_15[K_8] extends infer T_17 ? T_17 extends T_15[K_8] ? T_17 extends CanBeExpanded ? any : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_9 in keyof T_17]-?: any; } : T_17 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_9 in keyof T_14]-?: T_14[K_9] extends infer T_17 ? T_17 extends T_14[K_9] ? T_17 extends CanBeExpanded ? T_17[PrefixWith<`${string & K_5}`, K_9, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_5}`, K_9, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_17[PrefixWith<`${string & K_5}`, K_9, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_5}`, K_9, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_10 in keyof T_19]-?: any; } : T_19 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_11 in keyof T_17]-?: T_17[K_11] extends infer T_20 ? T_20 extends T_17[K_11] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_12 in keyof T_20]-?: T_20[K_12] extends infer T_21 ? T_21 extends T_20[K_12] ? T_21 extends CanBeExpanded ? T_21["default"] : T_21 : never : never; } : T_20 : never : never; } : T_17 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_10 in keyof T_12]-?: T_12[K_10] extends infer T_17 ? T_17 extends T_12[K_10] ? T_17 extends CanBeExpanded ? T_17[PrefixWith<`${string & K_5}`, K_10, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_5}`, K_10, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_17[PrefixWith<`${string & K_5}`, K_10, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_5}`, K_10, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_5}`, K_10, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_5}`, K_10, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[PrefixWith<`${string & K_5}`, K_10, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_5}`, K_10, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_11 in keyof T_20]-?: any; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_12 in keyof T_19]-?: T_19[K_12] extends infer T_21 ? T_21 extends T_19[K_12] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_13 in keyof T_21]-?: T_21[K_13] extends infer T_22 ? T_22 extends T_21[K_13] ? T_22 extends CanBeExpanded ? T_22["default"] : T_22 : never : never; } : T_21 : never : never; } : T_19 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_13 in keyof T_17]-?: T_17[K_13] extends infer T_21 ? T_21 extends T_17[K_13] ? T_21 extends CanBeExpanded ? T_21[PrefixWith, K_13, "."> extends infer T_22 ? T_22 extends PrefixWith, K_13, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith, K_13, "."> extends infer T_22 ? T_22 extends PrefixWith, K_13, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_14 in keyof T_23]-?: T_23[K_14] extends infer T_24 ? T_24 extends T_23[K_14] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_15 in keyof T_21]-?: T_21[K_15] extends infer T_24 ? T_24 extends T_21[K_15] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_21 : never : never; } : T_17 : never : never; } : T_12 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_6 in keyof T_6]-?: T_6[K_6] extends infer T_12 ? T_12 extends T_6[K_6] ? T_12 extends CanBeExpanded ? T_12[`${string & K_6}` extends infer T_13 ? T_13 extends `${string & K_6}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_6}` extends infer T_13 ? T_13 extends `${string & K_6}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_6}` extends infer T_13 ? T_13 extends `${string & K_6}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_6}` extends infer T_13 ? T_13 extends `${string & K_6}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_6}` extends infer T_13 ? T_13 extends `${string & K_6}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_6}` extends infer T_13 ? T_13 extends `${string & K_6}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_6}` extends infer T_13 ? T_13 extends `${string & K_6}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_6}` extends infer T_13 ? T_13 extends `${string & K_6}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? any : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_8 in keyof T_17]-?: any; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_9 in keyof T_16]-?: T_16[K_9] extends infer T_18 ? T_18 extends T_16[K_9] ? T_18 extends CanBeExpanded ? any : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_10 in keyof T_18]-?: any; } : T_18 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_10 in keyof T_15]-?: T_15[K_10] extends infer T_18 ? T_18 extends T_15[K_10] ? T_18 extends CanBeExpanded ? T_18[PrefixWith<`${string & K_6}`, K_10, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_10, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_18[PrefixWith<`${string & K_6}`, K_10, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_10, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_11 in keyof T_20]-?: any; } : T_20 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_12 in keyof T_18]-?: T_18[K_12] extends infer T_21 ? T_21 extends T_18[K_12] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_13 in keyof T_21]-?: T_21[K_13] extends infer T_22 ? T_22 extends T_21[K_13] ? T_22 extends CanBeExpanded ? T_22["default"] : T_22 : never : never; } : T_21 : never : never; } : T_18 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_11 in keyof T_14]-?: T_14[K_11] extends infer T_18 ? T_18 extends T_14[K_11] ? T_18 extends CanBeExpanded ? T_18[PrefixWith<`${string & K_6}`, K_11, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_11, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_18[PrefixWith<`${string & K_6}`, K_11, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_11, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_6}`, K_11, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_11, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[PrefixWith<`${string & K_6}`, K_11, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_11, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_12 in keyof T_21]-?: any; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_13 in keyof T_20]-?: T_20[K_13] extends infer T_22 ? T_22 extends T_20[K_13] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_14 in keyof T_22]-?: T_22[K_14] extends infer T_23 ? T_23 extends T_22[K_14] ? T_23 extends CanBeExpanded ? T_23["default"] : T_23 : never : never; } : T_22 : never : never; } : T_20 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_14 in keyof T_18]-?: T_18[K_14] extends infer T_22 ? T_22 extends T_18[K_14] ? T_22 extends CanBeExpanded ? T_22[PrefixWith, K_14, "."> extends infer T_23 ? T_23 extends PrefixWith, K_14, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith, K_14, "."> extends infer T_23 ? T_23 extends PrefixWith, K_14, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_15 in keyof T_24]-?: T_24[K_15] extends infer T_25 ? T_25 extends T_24[K_15] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_16 in keyof T_22]-?: T_22[K_16] extends infer T_25 ? T_25 extends T_22[K_16] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_22 : never : never; } : T_18 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_12 in keyof T_12]-?: T_12[K_12] extends infer T_18 ? T_18 extends T_12[K_12] ? T_18 extends CanBeExpanded ? T_18[PrefixWith<`${string & K_6}`, K_12, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_12, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_18[PrefixWith<`${string & K_6}`, K_12, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_12, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_6}`, K_12, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_12, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[PrefixWith<`${string & K_6}`, K_12, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_12, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_6}`, K_12, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_12, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_6}`, K_12, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_6}`, K_12, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_13 in keyof T_22]-?: any; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_14 in keyof T_21]-?: T_21[K_14] extends infer T_23 ? T_23 extends T_21[K_14] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_15 in keyof T_23]-?: T_23[K_15] extends infer T_24 ? T_24 extends T_23[K_15] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_15 in keyof T_20]-?: T_20[K_15] extends infer T_23 ? T_23 extends T_20[K_15] ? T_23 extends CanBeExpanded ? T_23[PrefixWith, K_15, "."> extends infer T_24 ? T_24 extends PrefixWith, K_15, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith, K_15, "."> extends infer T_24 ? T_24 extends PrefixWith, K_15, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_16 in keyof T_25]-?: T_25[K_16] extends infer T_26 ? T_26 extends T_25[K_16] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_17 in keyof T_23]-?: T_23[K_17] extends infer T_26 ? T_26 extends T_23[K_17] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_23 : never : never; } : T_20 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_16 in keyof T_18]-?: T_18[K_16] extends infer T_23 ? T_23 extends T_18[K_16] ? T_23 extends CanBeExpanded ? T_23[PrefixWith, K_16, "."> extends infer T_24 ? T_24 extends PrefixWith, K_16, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith, K_16, "."> extends infer T_24 ? T_24 extends PrefixWith, K_16, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_16, "."> extends infer T_24 ? T_24 extends PrefixWith, K_16, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith, K_16, "."> extends infer T_24 ? T_24 extends PrefixWith, K_16, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_17 in keyof T_26]-?: T_26[K_17] extends infer T_27 ? T_27 extends T_26[K_17] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_18 in keyof T_25]-?: T_25[K_18] extends infer T_27 ? T_27 extends T_25[K_18] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_19 in keyof T_23]-?: T_23[K_19] extends infer T_27 ? T_27 extends T_23[K_19] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_23 : never : never; } : T_18 : never : never; } : T_12 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_7 in keyof T_5]-?: T_5[K_7] extends infer T_12 ? T_12 extends T_5[K_7] ? T_12 extends CanBeExpanded ? T_12[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_7}` extends infer T_13 ? T_13 extends `${string & K_7}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? any : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_9 in keyof T_18]-?: any; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_10 in keyof T_17]-?: T_17[K_10] extends infer T_19 ? T_19 extends T_17[K_10] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_11 in keyof T_19]-?: any; } : T_19 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_11 in keyof T_16]-?: T_16[K_11] extends infer T_19 ? T_19 extends T_16[K_11] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_7}`, K_11, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_11, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_7}`, K_11, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_11, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_12 in keyof T_21]-?: any; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_13 in keyof T_19]-?: T_19[K_13] extends infer T_22 ? T_22 extends T_19[K_13] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_14 in keyof T_22]-?: T_22[K_14] extends infer T_23 ? T_23 extends T_22[K_14] ? T_23 extends CanBeExpanded ? T_23["default"] : T_23 : never : never; } : T_22 : never : never; } : T_19 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_12 in keyof T_15]-?: T_15[K_12] extends infer T_19 ? T_19 extends T_15[K_12] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_7}`, K_12, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_12, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_7}`, K_12, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_12, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_7}`, K_12, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_12, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_7}`, K_12, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_12, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_13 in keyof T_22]-?: any; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_14 in keyof T_21]-?: T_21[K_14] extends infer T_23 ? T_23 extends T_21[K_14] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_15 in keyof T_23]-?: T_23[K_15] extends infer T_24 ? T_24 extends T_23[K_15] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_15 in keyof T_19]-?: T_19[K_15] extends infer T_23 ? T_23 extends T_19[K_15] ? T_23 extends CanBeExpanded ? T_23[PrefixWith, K_15, "."> extends infer T_24 ? T_24 extends PrefixWith, K_15, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith, K_15, "."> extends infer T_24 ? T_24 extends PrefixWith, K_15, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_16 in keyof T_25]-?: T_25[K_16] extends infer T_26 ? T_26 extends T_25[K_16] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_17 in keyof T_23]-?: T_23[K_17] extends infer T_26 ? T_26 extends T_23[K_17] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_23 : never : never; } : T_19 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_13 in keyof T_14]-?: T_14[K_13] extends infer T_19 ? T_19 extends T_14[K_13] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_7}`, K_13, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_13, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_7}`, K_13, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_13, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_7}`, K_13, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_13, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_7}`, K_13, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_13, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_7}`, K_13, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_13, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_7}`, K_13, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_13, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_14 in keyof T_23]-?: any; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_15 in keyof T_22]-?: T_22[K_15] extends infer T_24 ? T_24 extends T_22[K_15] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_16 in keyof T_24]-?: T_24[K_16] extends infer T_25 ? T_25 extends T_24[K_16] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_16 in keyof T_21]-?: T_21[K_16] extends infer T_24 ? T_24 extends T_21[K_16] ? T_24 extends CanBeExpanded ? T_24[PrefixWith, K_16, "."> extends infer T_25 ? T_25 extends PrefixWith, K_16, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_24[PrefixWith, K_16, "."> extends infer T_25 ? T_25 extends PrefixWith, K_16, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_17 in keyof T_26]-?: T_26[K_17] extends infer T_27 ? T_27 extends T_26[K_17] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_18 in keyof T_24]-?: T_24[K_18] extends infer T_27 ? T_27 extends T_24[K_18] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_24 : never : never; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_17 in keyof T_19]-?: T_19[K_17] extends infer T_24 ? T_24 extends T_19[K_17] ? T_24 extends CanBeExpanded ? T_24[PrefixWith, K_17, "."> extends infer T_25 ? T_25 extends PrefixWith, K_17, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_24[PrefixWith, K_17, "."> extends infer T_25 ? T_25 extends PrefixWith, K_17, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_17, "."> extends infer T_25 ? T_25 extends PrefixWith, K_17, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith, K_17, "."> extends infer T_25 ? T_25 extends PrefixWith, K_17, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_18 in keyof T_27]-?: T_27[K_18] extends infer T_28 ? T_28 extends T_27[K_18] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_19 in keyof T_26]-?: T_26[K_19] extends infer T_28 ? T_28 extends T_26[K_19] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_26 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_20 in keyof T_24]-?: T_24[K_20] extends infer T_28 ? T_28 extends T_24[K_20] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_24 : never : never; } : T_19 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_14 in keyof T_12]-?: T_12[K_14] extends infer T_19 ? T_19 extends T_12[K_14] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_7}`, K_14, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_14, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_7}`, K_14, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_14, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_7}`, K_14, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_14, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_7}`, K_14, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_14, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_7}`, K_14, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_14, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_7}`, K_14, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_14, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_7}`, K_14, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_14, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_7}`, K_14, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_7}`, K_14, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_15 in keyof T_24]-?: any; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_16 in keyof T_23]-?: T_23[K_16] extends infer T_25 ? T_25 extends T_23[K_16] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_17 in keyof T_25]-?: T_25[K_17] extends infer T_26 ? T_26 extends T_25[K_17] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_17 in keyof T_22]-?: T_22[K_17] extends infer T_25 ? T_25 extends T_22[K_17] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_17, "."> extends infer T_26 ? T_26 extends PrefixWith, K_17, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_17, "."> extends infer T_26 ? T_26 extends PrefixWith, K_17, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_18 in keyof T_27]-?: T_27[K_18] extends infer T_28 ? T_28 extends T_27[K_18] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_19 in keyof T_25]-?: T_25[K_19] extends infer T_28 ? T_28 extends T_25[K_19] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_25 : never : never; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_18 in keyof T_21]-?: T_21[K_18] extends infer T_25 ? T_25 extends T_21[K_18] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_18, "."> extends infer T_26 ? T_26 extends PrefixWith, K_18, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_18, "."> extends infer T_26 ? T_26 extends PrefixWith, K_18, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_18, "."> extends infer T_26 ? T_26 extends PrefixWith, K_18, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith, K_18, "."> extends infer T_26 ? T_26 extends PrefixWith, K_18, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_19 in keyof T_28]-?: T_28[K_19] extends infer T_29 ? T_29 extends T_28[K_19] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_20 in keyof T_27]-?: T_27[K_20] extends infer T_29 ? T_29 extends T_27[K_20] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_21 in keyof T_25]-?: T_25[K_21] extends infer T_29 ? T_29 extends T_25[K_21] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_25 : never : never; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_19 in keyof T_19]-?: T_19[K_19] extends infer T_25 ? T_25 extends T_19[K_19] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_19, "."> extends infer T_26 ? T_26 extends PrefixWith, K_19, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_19, "."> extends infer T_26 ? T_26 extends PrefixWith, K_19, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_19, "."> extends infer T_26 ? T_26 extends PrefixWith, K_19, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith, K_19, "."> extends infer T_26 ? T_26 extends PrefixWith, K_19, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_19, "."> extends infer T_26 ? T_26 extends PrefixWith, K_19, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_19, "."> extends infer T_26 ? T_26 extends PrefixWith, K_19, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_20 in keyof T_29]-?: T_29[K_20] extends infer T_30 ? T_30 extends T_29[K_20] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_21 in keyof T_28]-?: T_28[K_21] extends infer T_30 ? T_30 extends T_28[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_22 in keyof T_27]-?: T_27[K_22] extends infer T_30 ? T_30 extends T_27[K_22] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_23 in keyof T_25]-?: T_25[K_23] extends infer T_30 ? T_30 extends T_25[K_23] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_25 : never : never; } : T_19 : never : never; } : T_12 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_8 in keyof T_4]-?: T_4[K_8] extends infer T_12 ? T_12 extends T_4[K_8] ? T_12 extends CanBeExpanded ? T_12[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_8}` extends infer T_13 ? T_13 extends `${string & K_8}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_10 in keyof T_19]-?: any; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_11 in keyof T_18]-?: T_18[K_11] extends infer T_20 ? T_20 extends T_18[K_11] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_12 in keyof T_20]-?: any; } : T_20 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_12 in keyof T_17]-?: T_17[K_12] extends infer T_20 ? T_20 extends T_17[K_12] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_8}`, K_12, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_12, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_8}`, K_12, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_12, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_13 in keyof T_22]-?: any; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_14 in keyof T_20]-?: T_20[K_14] extends infer T_23 ? T_23 extends T_20[K_14] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_15 in keyof T_23]-?: T_23[K_15] extends infer T_24 ? T_24 extends T_23[K_15] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never; } : T_20 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_13 in keyof T_16]-?: T_16[K_13] extends infer T_20 ? T_20 extends T_16[K_13] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_8}`, K_13, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_13, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_8}`, K_13, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_13, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_8}`, K_13, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_13, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_8}`, K_13, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_13, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_14 in keyof T_23]-?: any; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_15 in keyof T_22]-?: T_22[K_15] extends infer T_24 ? T_24 extends T_22[K_15] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_16 in keyof T_24]-?: T_24[K_16] extends infer T_25 ? T_25 extends T_24[K_16] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_16 in keyof T_20]-?: T_20[K_16] extends infer T_24 ? T_24 extends T_20[K_16] ? T_24 extends CanBeExpanded ? T_24[PrefixWith, K_16, "."> extends infer T_25 ? T_25 extends PrefixWith, K_16, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_24[PrefixWith, K_16, "."> extends infer T_25 ? T_25 extends PrefixWith, K_16, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_17 in keyof T_26]-?: T_26[K_17] extends infer T_27 ? T_27 extends T_26[K_17] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_18 in keyof T_24]-?: T_24[K_18] extends infer T_27 ? T_27 extends T_24[K_18] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_24 : never : never; } : T_20 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_14 in keyof T_15]-?: T_15[K_14] extends infer T_20 ? T_20 extends T_15[K_14] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_8}`, K_14, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_14, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_8}`, K_14, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_14, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_8}`, K_14, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_14, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_8}`, K_14, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_14, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_8}`, K_14, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_14, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_8}`, K_14, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_14, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_15 in keyof T_24]-?: any; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_16 in keyof T_23]-?: T_23[K_16] extends infer T_25 ? T_25 extends T_23[K_16] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_17 in keyof T_25]-?: T_25[K_17] extends infer T_26 ? T_26 extends T_25[K_17] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_17 in keyof T_22]-?: T_22[K_17] extends infer T_25 ? T_25 extends T_22[K_17] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_17, "."> extends infer T_26 ? T_26 extends PrefixWith, K_17, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_17, "."> extends infer T_26 ? T_26 extends PrefixWith, K_17, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_18 in keyof T_27]-?: T_27[K_18] extends infer T_28 ? T_28 extends T_27[K_18] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_19 in keyof T_25]-?: T_25[K_19] extends infer T_28 ? T_28 extends T_25[K_19] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_25 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_18 in keyof T_20]-?: T_20[K_18] extends infer T_25 ? T_25 extends T_20[K_18] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_18, "."> extends infer T_26 ? T_26 extends PrefixWith, K_18, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_18, "."> extends infer T_26 ? T_26 extends PrefixWith, K_18, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_18, "."> extends infer T_26 ? T_26 extends PrefixWith, K_18, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith, K_18, "."> extends infer T_26 ? T_26 extends PrefixWith, K_18, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_19 in keyof T_28]-?: T_28[K_19] extends infer T_29 ? T_29 extends T_28[K_19] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_20 in keyof T_27]-?: T_27[K_20] extends infer T_29 ? T_29 extends T_27[K_20] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_21 in keyof T_25]-?: T_25[K_21] extends infer T_29 ? T_29 extends T_25[K_21] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_25 : never : never; } : T_20 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_15 in keyof T_14]-?: T_14[K_15] extends infer T_20 ? T_20 extends T_14[K_15] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_8}`, K_15, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_15, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_8}`, K_15, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_15, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_8}`, K_15, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_15, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_8}`, K_15, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_15, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_8}`, K_15, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_15, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_8}`, K_15, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_15, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_8}`, K_15, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_15, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_8}`, K_15, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_15, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_16 in keyof T_25]-?: any; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_17 in keyof T_24]-?: T_24[K_17] extends infer T_26 ? T_26 extends T_24[K_17] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_18 in keyof T_26]-?: T_26[K_18] extends infer T_27 ? T_27 extends T_26[K_18] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_18 in keyof T_23]-?: T_23[K_18] extends infer T_26 ? T_26 extends T_23[K_18] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_18, "."> extends infer T_27 ? T_27 extends PrefixWith, K_18, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_18, "."> extends infer T_27 ? T_27 extends PrefixWith, K_18, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_19 in keyof T_28]-?: T_28[K_19] extends infer T_29 ? T_29 extends T_28[K_19] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_20 in keyof T_26]-?: T_26[K_20] extends infer T_29 ? T_29 extends T_26[K_20] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_26 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_19 in keyof T_22]-?: T_22[K_19] extends infer T_26 ? T_26 extends T_22[K_19] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_19, "."> extends infer T_27 ? T_27 extends PrefixWith, K_19, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_19, "."> extends infer T_27 ? T_27 extends PrefixWith, K_19, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_19, "."> extends infer T_27 ? T_27 extends PrefixWith, K_19, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_19, "."> extends infer T_27 ? T_27 extends PrefixWith, K_19, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_20 in keyof T_29]-?: T_29[K_20] extends infer T_30 ? T_30 extends T_29[K_20] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_21 in keyof T_28]-?: T_28[K_21] extends infer T_30 ? T_30 extends T_28[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_22 in keyof T_26]-?: T_26[K_22] extends infer T_30 ? T_30 extends T_26[K_22] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_26 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_20 in keyof T_20]-?: T_20[K_20] extends infer T_26 ? T_26 extends T_20[K_20] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_20, "."> extends infer T_27 ? T_27 extends PrefixWith, K_20, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_20, "."> extends infer T_27 ? T_27 extends PrefixWith, K_20, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_20, "."> extends infer T_27 ? T_27 extends PrefixWith, K_20, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_20, "."> extends infer T_27 ? T_27 extends PrefixWith, K_20, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_20, "."> extends infer T_27 ? T_27 extends PrefixWith, K_20, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_20, "."> extends infer T_27 ? T_27 extends PrefixWith, K_20, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_21 in keyof T_30]-?: T_30[K_21] extends infer T_31 ? T_31 extends T_30[K_21] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_22 in keyof T_29]-?: T_29[K_22] extends infer T_31 ? T_31 extends T_29[K_22] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_23 in keyof T_28]-?: T_28[K_23] extends infer T_31 ? T_31 extends T_28[K_23] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_24 in keyof T_26]-?: T_26[K_24] extends infer T_31 ? T_31 extends T_26[K_24] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_26 : never : never; } : T_20 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_16 in keyof T_12]-?: T_12[K_16] extends infer T_20 ? T_20 extends T_12[K_16] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_8}`, K_16, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_8}`, K_16, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_17 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_18 in keyof T_25]-?: T_25[K_18] extends infer T_27 ? T_27 extends T_25[K_18] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_19 in keyof T_27]-?: T_27[K_19] extends infer T_28 ? T_28 extends T_27[K_19] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_19 in keyof T_24]-?: T_24[K_19] extends infer T_27 ? T_27 extends T_24[K_19] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_19, "."> extends infer T_28 ? T_28 extends PrefixWith, K_19, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_19, "."> extends infer T_28 ? T_28 extends PrefixWith, K_19, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_20 in keyof T_29]-?: T_29[K_20] extends infer T_30 ? T_30 extends T_29[K_20] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_21 in keyof T_27]-?: T_27[K_21] extends infer T_30 ? T_30 extends T_27[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_20 in keyof T_23]-?: T_23[K_20] extends infer T_27 ? T_27 extends T_23[K_20] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_21 in keyof T_30]-?: T_30[K_21] extends infer T_31 ? T_31 extends T_30[K_21] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_22 in keyof T_29]-?: T_29[K_22] extends infer T_31 ? T_31 extends T_29[K_22] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_23 in keyof T_27]-?: T_27[K_23] extends infer T_31 ? T_31 extends T_27[K_23] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_27 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_21 in keyof T_22]-?: T_22[K_21] extends infer T_27 ? T_27 extends T_22[K_21] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_22 in keyof T_31]-?: T_31[K_22] extends infer T_32 ? T_32 extends T_31[K_22] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_23 in keyof T_30]-?: T_30[K_23] extends infer T_32 ? T_32 extends T_30[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_24 in keyof T_29]-?: T_29[K_24] extends infer T_32 ? T_32 extends T_29[K_24] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_25 in keyof T_27]-?: T_27[K_25] extends infer T_32 ? T_32 extends T_27[K_25] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_27 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_22 in keyof T_20]-?: T_20[K_22] extends infer T_27 ? T_27 extends T_20[K_22] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_22, "."> extends infer T_28 ? T_28 extends PrefixWith, K_22, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_22, "."> extends infer T_28 ? T_28 extends PrefixWith, K_22, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_22, "."> extends infer T_28 ? T_28 extends PrefixWith, K_22, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_22, "."> extends infer T_28 ? T_28 extends PrefixWith, K_22, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_22, "."> extends infer T_28 ? T_28 extends PrefixWith, K_22, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_22, "."> extends infer T_28 ? T_28 extends PrefixWith, K_22, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_22, "."> extends infer T_28 ? T_28 extends PrefixWith, K_22, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_22, "."> extends infer T_28 ? T_28 extends PrefixWith, K_22, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_23 in keyof T_32]-?: T_32[K_23] extends infer T_33 ? T_33 extends T_32[K_23] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_24 in keyof T_31]-?: T_31[K_24] extends infer T_33 ? T_33 extends T_31[K_24] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_25 in keyof T_30]-?: T_30[K_25] extends infer T_33 ? T_33 extends T_30[K_25] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_26 in keyof T_29]-?: T_29[K_26] extends infer T_33 ? T_33 extends T_29[K_26] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_27 in keyof T_27]-?: T_27[K_27] extends infer T_33 ? T_33 extends T_27[K_27] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_27 : never : never; } : T_20 : never : never; } : T_12 : never : never; } : T_4 : never : never : T_3 extends (infer U)[] ? any[] : T_3 extends object ? { [K_9 in keyof T_3]-?: T_3[K_9] extends infer T_12 ? T_12 extends T_3[K_9] ? T_12 extends CanBeExpanded ? T_12[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[`${string & K_9}` extends infer T_13 ? T_13 extends `${string & K_9}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_11 in keyof T_20]-?: any; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_12 in keyof T_19]-?: T_19[K_12] extends infer T_21 ? T_21 extends T_19[K_12] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_13 in keyof T_21]-?: any; } : T_21 : never : never; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_13 in keyof T_18]-?: T_18[K_13] extends infer T_21 ? T_21 extends T_18[K_13] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_9}`, K_13, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_13, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_9}`, K_13, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_13, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_14 in keyof T_23]-?: any; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_15 in keyof T_21]-?: T_21[K_15] extends infer T_24 ? T_24 extends T_21[K_15] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_16 in keyof T_24]-?: T_24[K_16] extends infer T_25 ? T_25 extends T_24[K_16] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never; } : T_21 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_14 in keyof T_17]-?: T_17[K_14] extends infer T_21 ? T_21 extends T_17[K_14] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_9}`, K_14, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_14, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_9}`, K_14, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_14, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_9}`, K_14, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_14, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_9}`, K_14, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_14, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_15 in keyof T_24]-?: any; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_16 in keyof T_23]-?: T_23[K_16] extends infer T_25 ? T_25 extends T_23[K_16] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_17 in keyof T_25]-?: T_25[K_17] extends infer T_26 ? T_26 extends T_25[K_17] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_17 in keyof T_21]-?: T_21[K_17] extends infer T_25 ? T_25 extends T_21[K_17] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_17, "."> extends infer T_26 ? T_26 extends PrefixWith, K_17, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_17, "."> extends infer T_26 ? T_26 extends PrefixWith, K_17, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_18 in keyof T_27]-?: T_27[K_18] extends infer T_28 ? T_28 extends T_27[K_18] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_19 in keyof T_25]-?: T_25[K_19] extends infer T_28 ? T_28 extends T_25[K_19] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_25 : never : never; } : T_21 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_15 in keyof T_16]-?: T_16[K_15] extends infer T_21 ? T_21 extends T_16[K_15] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_9}`, K_15, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_15, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_9}`, K_15, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_15, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_9}`, K_15, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_15, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_9}`, K_15, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_15, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_9}`, K_15, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_15, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_9}`, K_15, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_15, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_16 in keyof T_25]-?: any; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_17 in keyof T_24]-?: T_24[K_17] extends infer T_26 ? T_26 extends T_24[K_17] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_18 in keyof T_26]-?: T_26[K_18] extends infer T_27 ? T_27 extends T_26[K_18] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_18 in keyof T_23]-?: T_23[K_18] extends infer T_26 ? T_26 extends T_23[K_18] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_18, "."> extends infer T_27 ? T_27 extends PrefixWith, K_18, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_18, "."> extends infer T_27 ? T_27 extends PrefixWith, K_18, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_19 in keyof T_28]-?: T_28[K_19] extends infer T_29 ? T_29 extends T_28[K_19] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_20 in keyof T_26]-?: T_26[K_20] extends infer T_29 ? T_29 extends T_26[K_20] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_26 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_19 in keyof T_21]-?: T_21[K_19] extends infer T_26 ? T_26 extends T_21[K_19] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_19, "."> extends infer T_27 ? T_27 extends PrefixWith, K_19, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_19, "."> extends infer T_27 ? T_27 extends PrefixWith, K_19, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_19, "."> extends infer T_27 ? T_27 extends PrefixWith, K_19, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_19, "."> extends infer T_27 ? T_27 extends PrefixWith, K_19, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_20 in keyof T_29]-?: T_29[K_20] extends infer T_30 ? T_30 extends T_29[K_20] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_21 in keyof T_28]-?: T_28[K_21] extends infer T_30 ? T_30 extends T_28[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_22 in keyof T_26]-?: T_26[K_22] extends infer T_30 ? T_30 extends T_26[K_22] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_26 : never : never; } : T_21 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_16 in keyof T_15]-?: T_15[K_16] extends infer T_21 ? T_21 extends T_15[K_16] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_9}`, K_16, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_16, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_9}`, K_16, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_16, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_9}`, K_16, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_16, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_9}`, K_16, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_16, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_9}`, K_16, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_16, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_9}`, K_16, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_16, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_9}`, K_16, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_16, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_9}`, K_16, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_16, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_17 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_18 in keyof T_25]-?: T_25[K_18] extends infer T_27 ? T_27 extends T_25[K_18] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_19 in keyof T_27]-?: T_27[K_19] extends infer T_28 ? T_28 extends T_27[K_19] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_19 in keyof T_24]-?: T_24[K_19] extends infer T_27 ? T_27 extends T_24[K_19] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_19, "."> extends infer T_28 ? T_28 extends PrefixWith, K_19, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_19, "."> extends infer T_28 ? T_28 extends PrefixWith, K_19, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_20 in keyof T_29]-?: T_29[K_20] extends infer T_30 ? T_30 extends T_29[K_20] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_21 in keyof T_27]-?: T_27[K_21] extends infer T_30 ? T_30 extends T_27[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_20 in keyof T_23]-?: T_23[K_20] extends infer T_27 ? T_27 extends T_23[K_20] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_21 in keyof T_30]-?: T_30[K_21] extends infer T_31 ? T_31 extends T_30[K_21] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_22 in keyof T_29]-?: T_29[K_22] extends infer T_31 ? T_31 extends T_29[K_22] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_23 in keyof T_27]-?: T_27[K_23] extends infer T_31 ? T_31 extends T_27[K_23] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_27 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_21 in keyof T_21]-?: T_21[K_21] extends infer T_27 ? T_27 extends T_21[K_21] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_21, "."> extends infer T_28 ? T_28 extends PrefixWith, K_21, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_22 in keyof T_31]-?: T_31[K_22] extends infer T_32 ? T_32 extends T_31[K_22] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_23 in keyof T_30]-?: T_30[K_23] extends infer T_32 ? T_32 extends T_30[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_24 in keyof T_29]-?: T_29[K_24] extends infer T_32 ? T_32 extends T_29[K_24] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_25 in keyof T_27]-?: T_27[K_25] extends infer T_32 ? T_32 extends T_27[K_25] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_27 : never : never; } : T_21 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_17 in keyof T_14]-?: T_14[K_17] extends infer T_21 ? T_21 extends T_14[K_17] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_9}`, K_17, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_17, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_18 in keyof T_27]-?: any; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_19 in keyof T_26]-?: T_26[K_19] extends infer T_28 ? T_28 extends T_26[K_19] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_20 in keyof T_28]-?: T_28[K_20] extends infer T_29 ? T_29 extends T_28[K_20] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_20 in keyof T_25]-?: T_25[K_20] extends infer T_28 ? T_28 extends T_25[K_20] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_20, "."> extends infer T_29 ? T_29 extends PrefixWith, K_20, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_20, "."> extends infer T_29 ? T_29 extends PrefixWith, K_20, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_21 in keyof T_30]-?: T_30[K_21] extends infer T_31 ? T_31 extends T_30[K_21] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_22 in keyof T_28]-?: T_28[K_22] extends infer T_31 ? T_31 extends T_28[K_22] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_21 in keyof T_24]-?: T_24[K_21] extends infer T_28 ? T_28 extends T_24[K_21] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_22 in keyof T_31]-?: T_31[K_22] extends infer T_32 ? T_32 extends T_31[K_22] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_23 in keyof T_30]-?: T_30[K_23] extends infer T_32 ? T_32 extends T_30[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_24 in keyof T_28]-?: T_28[K_24] extends infer T_32 ? T_32 extends T_28[K_24] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_28 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_22 in keyof T_23]-?: T_23[K_22] extends infer T_28 ? T_28 extends T_23[K_22] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_23 in keyof T_32]-?: T_32[K_23] extends infer T_33 ? T_33 extends T_32[K_23] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_24 in keyof T_31]-?: T_31[K_24] extends infer T_33 ? T_33 extends T_31[K_24] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_25 in keyof T_30]-?: T_30[K_25] extends infer T_33 ? T_33 extends T_30[K_25] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_26 in keyof T_28]-?: T_28[K_26] extends infer T_33 ? T_33 extends T_28[K_26] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_28 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_23 in keyof T_21]-?: T_21[K_23] extends infer T_28 ? T_28 extends T_21[K_23] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_23, "."> extends infer T_29 ? T_29 extends PrefixWith, K_23, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_23, "."> extends infer T_29 ? T_29 extends PrefixWith, K_23, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_23, "."> extends infer T_29 ? T_29 extends PrefixWith, K_23, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_23, "."> extends infer T_29 ? T_29 extends PrefixWith, K_23, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_23, "."> extends infer T_29 ? T_29 extends PrefixWith, K_23, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_23, "."> extends infer T_29 ? T_29 extends PrefixWith, K_23, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_23, "."> extends infer T_29 ? T_29 extends PrefixWith, K_23, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_23, "."> extends infer T_29 ? T_29 extends PrefixWith, K_23, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_24 in keyof T_33]-?: T_33[K_24] extends infer T_34 ? T_34 extends T_33[K_24] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_25 in keyof T_32]-?: T_32[K_25] extends infer T_34 ? T_34 extends T_32[K_25] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_26 in keyof T_31]-?: T_31[K_26] extends infer T_34 ? T_34 extends T_31[K_26] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_27 in keyof T_30]-?: T_30[K_27] extends infer T_34 ? T_34 extends T_30[K_27] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_28 in keyof T_28]-?: T_28[K_28] extends infer T_34 ? T_34 extends T_28[K_28] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_28 : never : never; } : T_21 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_18 in keyof T_12]-?: T_12[K_18] extends infer T_21 ? T_21 extends T_12[K_18] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_9}`, K_18, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_9}`, K_18, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_19 in keyof T_28]-?: any; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_20 in keyof T_27]-?: T_27[K_20] extends infer T_29 ? T_29 extends T_27[K_20] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_21 in keyof T_29]-?: T_29[K_21] extends infer T_30 ? T_30 extends T_29[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_21 in keyof T_26]-?: T_26[K_21] extends infer T_29 ? T_29 extends T_26[K_21] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_21, "."> extends infer T_30 ? T_30 extends PrefixWith, K_21, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_21, "."> extends infer T_30 ? T_30 extends PrefixWith, K_21, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_22 in keyof T_31]-?: T_31[K_22] extends infer T_32 ? T_32 extends T_31[K_22] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_23 in keyof T_29]-?: T_29[K_23] extends infer T_32 ? T_32 extends T_29[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_22 in keyof T_25]-?: T_25[K_22] extends infer T_29 ? T_29 extends T_25[K_22] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_23 in keyof T_32]-?: T_32[K_23] extends infer T_33 ? T_33 extends T_32[K_23] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_24 in keyof T_31]-?: T_31[K_24] extends infer T_33 ? T_33 extends T_31[K_24] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_25 in keyof T_29]-?: T_29[K_25] extends infer T_33 ? T_33 extends T_29[K_25] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_23 in keyof T_24]-?: T_24[K_23] extends infer T_29 ? T_29 extends T_24[K_23] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_24 in keyof T_33]-?: T_33[K_24] extends infer T_34 ? T_34 extends T_33[K_24] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_25 in keyof T_32]-?: T_32[K_25] extends infer T_34 ? T_34 extends T_32[K_25] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_26 in keyof T_31]-?: T_31[K_26] extends infer T_34 ? T_34 extends T_31[K_26] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_27 in keyof T_29]-?: T_29[K_27] extends infer T_34 ? T_34 extends T_29[K_27] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_29 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_24 in keyof T_23]-?: T_23[K_24] extends infer T_29 ? T_29 extends T_23[K_24] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_25 in keyof T_34]-?: T_34[K_25] extends infer T_35 ? T_35 extends T_34[K_25] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_26 in keyof T_33]-?: T_33[K_26] extends infer T_35 ? T_35 extends T_33[K_26] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_27 in keyof T_32]-?: T_32[K_27] extends infer T_35 ? T_35 extends T_32[K_27] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_28 in keyof T_31]-?: T_31[K_28] extends infer T_35 ? T_35 extends T_31[K_28] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_29 in keyof T_29]-?: T_29[K_29] extends infer T_35 ? T_35 extends T_29[K_29] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_29 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_25 in keyof T_21]-?: T_21[K_25] extends infer T_29 ? T_29 extends T_21[K_25] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_25, "."> extends infer T_30 ? T_30 extends PrefixWith, K_25, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_26 in keyof T_35]-?: T_35[K_26] extends infer T_36 ? T_36 extends T_35[K_26] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_27 in keyof T_34]-?: T_34[K_27] extends infer T_36 ? T_36 extends T_34[K_27] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_28 in keyof T_33]-?: T_33[K_28] extends infer T_36 ? T_36 extends T_33[K_28] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_29 in keyof T_32]-?: T_32[K_29] extends infer T_36 ? T_36 extends T_32[K_29] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_30 in keyof T_31]-?: T_31[K_30] extends infer T_36 ? T_36 extends T_31[K_30] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_31 in keyof T_29]-?: T_29[K_31] extends infer T_36 ? T_36 extends T_29[K_31] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_29 : never : never; } : T_21 : never : never; } : T_12 : never : never; } : T_3 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_10 in keyof T_2]-?: T_2[K_10] extends infer T_12 ? T_12 extends T_2[K_10] ? T_12 extends CanBeExpanded ? T_12[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[`${string & K_10}` extends infer T_13 ? T_13 extends `${string & K_10}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_12 in keyof T_21]-?: any; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_13 in keyof T_20]-?: T_20[K_13] extends infer T_22 ? T_22 extends T_20[K_13] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_14 in keyof T_22]-?: any; } : T_22 : never : never; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_14 in keyof T_19]-?: T_19[K_14] extends infer T_22 ? T_22 extends T_19[K_14] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_10}`, K_14, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_14, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_10}`, K_14, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_14, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_15 in keyof T_24]-?: any; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_16 in keyof T_22]-?: T_22[K_16] extends infer T_25 ? T_25 extends T_22[K_16] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_17 in keyof T_25]-?: T_25[K_17] extends infer T_26 ? T_26 extends T_25[K_17] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_22 : never : never; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_15 in keyof T_18]-?: T_18[K_15] extends infer T_22 ? T_22 extends T_18[K_15] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_10}`, K_15, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_15, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_10}`, K_15, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_15, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_10}`, K_15, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_15, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_10}`, K_15, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_15, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_16 in keyof T_25]-?: any; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_17 in keyof T_24]-?: T_24[K_17] extends infer T_26 ? T_26 extends T_24[K_17] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_18 in keyof T_26]-?: T_26[K_18] extends infer T_27 ? T_27 extends T_26[K_18] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_18 in keyof T_22]-?: T_22[K_18] extends infer T_26 ? T_26 extends T_22[K_18] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_18, "."> extends infer T_27 ? T_27 extends PrefixWith, K_18, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_18, "."> extends infer T_27 ? T_27 extends PrefixWith, K_18, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_19 in keyof T_28]-?: T_28[K_19] extends infer T_29 ? T_29 extends T_28[K_19] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_20 in keyof T_26]-?: T_26[K_20] extends infer T_29 ? T_29 extends T_26[K_20] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_26 : never : never; } : T_22 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_16 in keyof T_17]-?: T_17[K_16] extends infer T_22 ? T_22 extends T_17[K_16] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_10}`, K_16, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_16, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_10}`, K_16, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_16, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_10}`, K_16, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_16, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_10}`, K_16, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_16, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_10}`, K_16, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_16, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_10}`, K_16, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_16, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_17 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_18 in keyof T_25]-?: T_25[K_18] extends infer T_27 ? T_27 extends T_25[K_18] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_19 in keyof T_27]-?: T_27[K_19] extends infer T_28 ? T_28 extends T_27[K_19] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_19 in keyof T_24]-?: T_24[K_19] extends infer T_27 ? T_27 extends T_24[K_19] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_19, "."> extends infer T_28 ? T_28 extends PrefixWith, K_19, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_19, "."> extends infer T_28 ? T_28 extends PrefixWith, K_19, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_20 in keyof T_29]-?: T_29[K_20] extends infer T_30 ? T_30 extends T_29[K_20] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_21 in keyof T_27]-?: T_27[K_21] extends infer T_30 ? T_30 extends T_27[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_20 in keyof T_22]-?: T_22[K_20] extends infer T_27 ? T_27 extends T_22[K_20] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_20, "."> extends infer T_28 ? T_28 extends PrefixWith, K_20, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_21 in keyof T_30]-?: T_30[K_21] extends infer T_31 ? T_31 extends T_30[K_21] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_22 in keyof T_29]-?: T_29[K_22] extends infer T_31 ? T_31 extends T_29[K_22] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_23 in keyof T_27]-?: T_27[K_23] extends infer T_31 ? T_31 extends T_27[K_23] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_27 : never : never; } : T_22 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_17 in keyof T_16]-?: T_16[K_17] extends infer T_22 ? T_22 extends T_16[K_17] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_10}`, K_17, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_17, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_10}`, K_17, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_17, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_10}`, K_17, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_17, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_10}`, K_17, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_17, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_10}`, K_17, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_17, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_10}`, K_17, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_17, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_10}`, K_17, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_17, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_10}`, K_17, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_17, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_18 in keyof T_27]-?: any; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_19 in keyof T_26]-?: T_26[K_19] extends infer T_28 ? T_28 extends T_26[K_19] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_20 in keyof T_28]-?: T_28[K_20] extends infer T_29 ? T_29 extends T_28[K_20] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_20 in keyof T_25]-?: T_25[K_20] extends infer T_28 ? T_28 extends T_25[K_20] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_20, "."> extends infer T_29 ? T_29 extends PrefixWith, K_20, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_20, "."> extends infer T_29 ? T_29 extends PrefixWith, K_20, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_21 in keyof T_30]-?: T_30[K_21] extends infer T_31 ? T_31 extends T_30[K_21] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_22 in keyof T_28]-?: T_28[K_22] extends infer T_31 ? T_31 extends T_28[K_22] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_21 in keyof T_24]-?: T_24[K_21] extends infer T_28 ? T_28 extends T_24[K_21] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_22 in keyof T_31]-?: T_31[K_22] extends infer T_32 ? T_32 extends T_31[K_22] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_23 in keyof T_30]-?: T_30[K_23] extends infer T_32 ? T_32 extends T_30[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_24 in keyof T_28]-?: T_28[K_24] extends infer T_32 ? T_32 extends T_28[K_24] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_28 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_22 in keyof T_22]-?: T_22[K_22] extends infer T_28 ? T_28 extends T_22[K_22] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_22, "."> extends infer T_29 ? T_29 extends PrefixWith, K_22, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_23 in keyof T_32]-?: T_32[K_23] extends infer T_33 ? T_33 extends T_32[K_23] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_24 in keyof T_31]-?: T_31[K_24] extends infer T_33 ? T_33 extends T_31[K_24] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_25 in keyof T_30]-?: T_30[K_25] extends infer T_33 ? T_33 extends T_30[K_25] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_26 in keyof T_28]-?: T_28[K_26] extends infer T_33 ? T_33 extends T_28[K_26] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_28 : never : never; } : T_22 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_18 in keyof T_15]-?: T_15[K_18] extends infer T_22 ? T_22 extends T_15[K_18] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_10}`, K_18, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_18, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_19 in keyof T_28]-?: any; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_20 in keyof T_27]-?: T_27[K_20] extends infer T_29 ? T_29 extends T_27[K_20] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_21 in keyof T_29]-?: T_29[K_21] extends infer T_30 ? T_30 extends T_29[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_21 in keyof T_26]-?: T_26[K_21] extends infer T_29 ? T_29 extends T_26[K_21] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_21, "."> extends infer T_30 ? T_30 extends PrefixWith, K_21, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_21, "."> extends infer T_30 ? T_30 extends PrefixWith, K_21, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_22 in keyof T_31]-?: T_31[K_22] extends infer T_32 ? T_32 extends T_31[K_22] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_23 in keyof T_29]-?: T_29[K_23] extends infer T_32 ? T_32 extends T_29[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_22 in keyof T_25]-?: T_25[K_22] extends infer T_29 ? T_29 extends T_25[K_22] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_23 in keyof T_32]-?: T_32[K_23] extends infer T_33 ? T_33 extends T_32[K_23] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_24 in keyof T_31]-?: T_31[K_24] extends infer T_33 ? T_33 extends T_31[K_24] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_25 in keyof T_29]-?: T_29[K_25] extends infer T_33 ? T_33 extends T_29[K_25] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_23 in keyof T_24]-?: T_24[K_23] extends infer T_29 ? T_29 extends T_24[K_23] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_24 in keyof T_33]-?: T_33[K_24] extends infer T_34 ? T_34 extends T_33[K_24] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_25 in keyof T_32]-?: T_32[K_25] extends infer T_34 ? T_34 extends T_32[K_25] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_26 in keyof T_31]-?: T_31[K_26] extends infer T_34 ? T_34 extends T_31[K_26] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_27 in keyof T_29]-?: T_29[K_27] extends infer T_34 ? T_34 extends T_29[K_27] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_29 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_24 in keyof T_22]-?: T_22[K_24] extends infer T_29 ? T_29 extends T_22[K_24] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_24, "."> extends infer T_30 ? T_30 extends PrefixWith, K_24, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_25 in keyof T_34]-?: T_34[K_25] extends infer T_35 ? T_35 extends T_34[K_25] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_26 in keyof T_33]-?: T_33[K_26] extends infer T_35 ? T_35 extends T_33[K_26] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_27 in keyof T_32]-?: T_32[K_27] extends infer T_35 ? T_35 extends T_32[K_27] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_28 in keyof T_31]-?: T_31[K_28] extends infer T_35 ? T_35 extends T_31[K_28] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_29 in keyof T_29]-?: T_29[K_29] extends infer T_35 ? T_35 extends T_29[K_29] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_29 : never : never; } : T_22 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_19 in keyof T_14]-?: T_14[K_19] extends infer T_22 ? T_22 extends T_14[K_19] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_10}`, K_19, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_19, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_20 in keyof T_29]-?: any; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_21 in keyof T_28]-?: T_28[K_21] extends infer T_30 ? T_30 extends T_28[K_21] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_22 in keyof T_30]-?: T_30[K_22] extends infer T_31 ? T_31 extends T_30[K_22] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_22 in keyof T_27]-?: T_27[K_22] extends infer T_30 ? T_30 extends T_27[K_22] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_22, "."> extends infer T_31 ? T_31 extends PrefixWith, K_22, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_22, "."> extends infer T_31 ? T_31 extends PrefixWith, K_22, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_23 in keyof T_32]-?: T_32[K_23] extends infer T_33 ? T_33 extends T_32[K_23] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_24 in keyof T_30]-?: T_30[K_24] extends infer T_33 ? T_33 extends T_30[K_24] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_23 in keyof T_26]-?: T_26[K_23] extends infer T_30 ? T_30 extends T_26[K_23] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_23, "."> extends infer T_31 ? T_31 extends PrefixWith, K_23, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_23, "."> extends infer T_31 ? T_31 extends PrefixWith, K_23, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_23, "."> extends infer T_31 ? T_31 extends PrefixWith, K_23, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_23, "."> extends infer T_31 ? T_31 extends PrefixWith, K_23, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_24 in keyof T_33]-?: T_33[K_24] extends infer T_34 ? T_34 extends T_33[K_24] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_25 in keyof T_32]-?: T_32[K_25] extends infer T_34 ? T_34 extends T_32[K_25] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_26 in keyof T_30]-?: T_30[K_26] extends infer T_34 ? T_34 extends T_30[K_26] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_30 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_24 in keyof T_25]-?: T_25[K_24] extends infer T_30 ? T_30 extends T_25[K_24] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_25 in keyof T_34]-?: T_34[K_25] extends infer T_35 ? T_35 extends T_34[K_25] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_26 in keyof T_33]-?: T_33[K_26] extends infer T_35 ? T_35 extends T_33[K_26] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_27 in keyof T_32]-?: T_32[K_27] extends infer T_35 ? T_35 extends T_32[K_27] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_28 in keyof T_30]-?: T_30[K_28] extends infer T_35 ? T_35 extends T_30[K_28] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_30 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_25 in keyof T_24]-?: T_24[K_25] extends infer T_30 ? T_30 extends T_24[K_25] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_26 in keyof T_35]-?: T_35[K_26] extends infer T_36 ? T_36 extends T_35[K_26] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_27 in keyof T_34]-?: T_34[K_27] extends infer T_36 ? T_36 extends T_34[K_27] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_28 in keyof T_33]-?: T_33[K_28] extends infer T_36 ? T_36 extends T_33[K_28] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_29 in keyof T_32]-?: T_32[K_29] extends infer T_36 ? T_36 extends T_32[K_29] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_30 in keyof T_30]-?: T_30[K_30] extends infer T_36 ? T_36 extends T_30[K_30] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_30 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_26 in keyof T_22]-?: T_22[K_26] extends infer T_30 ? T_30 extends T_22[K_26] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_26, "."> extends infer T_31 ? T_31 extends PrefixWith, K_26, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_27 in keyof T_36]-?: T_36[K_27] extends infer T_37 ? T_37 extends T_36[K_27] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_28 in keyof T_35]-?: T_35[K_28] extends infer T_37 ? T_37 extends T_35[K_28] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_29 in keyof T_34]-?: T_34[K_29] extends infer T_37 ? T_37 extends T_34[K_29] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_30 in keyof T_33]-?: T_33[K_30] extends infer T_37 ? T_37 extends T_33[K_30] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_31 in keyof T_32]-?: T_32[K_31] extends infer T_37 ? T_37 extends T_32[K_31] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_32 in keyof T_30]-?: T_30[K_32] extends infer T_37 ? T_37 extends T_30[K_32] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_30 : never : never; } : T_22 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_20 in keyof T_12]-?: T_12[K_20] extends infer T_22 ? T_22 extends T_12[K_20] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_10}`, K_20, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_10}`, K_20, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_21 in keyof T_30]-?: any; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_22 in keyof T_29]-?: T_29[K_22] extends infer T_31 ? T_31 extends T_29[K_22] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_23 in keyof T_31]-?: T_31[K_23] extends infer T_32 ? T_32 extends T_31[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_23 in keyof T_28]-?: T_28[K_23] extends infer T_31 ? T_31 extends T_28[K_23] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_23, "."> extends infer T_32 ? T_32 extends PrefixWith, K_23, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_23, "."> extends infer T_32 ? T_32 extends PrefixWith, K_23, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_24 in keyof T_33]-?: T_33[K_24] extends infer T_34 ? T_34 extends T_33[K_24] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_25 in keyof T_31]-?: T_31[K_25] extends infer T_34 ? T_34 extends T_31[K_25] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_24 in keyof T_27]-?: T_27[K_24] extends infer T_31 ? T_31 extends T_27[K_24] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_24, "."> extends infer T_32 ? T_32 extends PrefixWith, K_24, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_24, "."> extends infer T_32 ? T_32 extends PrefixWith, K_24, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_24, "."> extends infer T_32 ? T_32 extends PrefixWith, K_24, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_24, "."> extends infer T_32 ? T_32 extends PrefixWith, K_24, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_25 in keyof T_34]-?: T_34[K_25] extends infer T_35 ? T_35 extends T_34[K_25] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_26 in keyof T_33]-?: T_33[K_26] extends infer T_35 ? T_35 extends T_33[K_26] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_27 in keyof T_31]-?: T_31[K_27] extends infer T_35 ? T_35 extends T_31[K_27] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_25 in keyof T_26]-?: T_26[K_25] extends infer T_31 ? T_31 extends T_26[K_25] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_26 in keyof T_35]-?: T_35[K_26] extends infer T_36 ? T_36 extends T_35[K_26] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_27 in keyof T_34]-?: T_34[K_27] extends infer T_36 ? T_36 extends T_34[K_27] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_28 in keyof T_33]-?: T_33[K_28] extends infer T_36 ? T_36 extends T_33[K_28] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_29 in keyof T_31]-?: T_31[K_29] extends infer T_36 ? T_36 extends T_31[K_29] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_31 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_26 in keyof T_25]-?: T_25[K_26] extends infer T_31 ? T_31 extends T_25[K_26] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_27 in keyof T_36]-?: T_36[K_27] extends infer T_37 ? T_37 extends T_36[K_27] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_28 in keyof T_35]-?: T_35[K_28] extends infer T_37 ? T_37 extends T_35[K_28] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_29 in keyof T_34]-?: T_34[K_29] extends infer T_37 ? T_37 extends T_34[K_29] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_30 in keyof T_33]-?: T_33[K_30] extends infer T_37 ? T_37 extends T_33[K_30] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_31 in keyof T_31]-?: T_31[K_31] extends infer T_37 ? T_37 extends T_31[K_31] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_31 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_27 in keyof T_24]-?: T_24[K_27] extends infer T_31 ? T_31 extends T_24[K_27] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_28 in keyof T_37]-?: T_37[K_28] extends infer T_38 ? T_38 extends T_37[K_28] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_29 in keyof T_36]-?: T_36[K_29] extends infer T_38 ? T_38 extends T_36[K_29] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_30 in keyof T_35]-?: T_35[K_30] extends infer T_38 ? T_38 extends T_35[K_30] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_31 in keyof T_34]-?: T_34[K_31] extends infer T_38 ? T_38 extends T_34[K_31] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_32 in keyof T_33]-?: T_33[K_32] extends infer T_38 ? T_38 extends T_33[K_32] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_33 in keyof T_31]-?: T_31[K_33] extends infer T_38 ? T_38 extends T_31[K_33] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_31 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_28 in keyof T_22]-?: T_22[K_28] extends infer T_31 ? T_31 extends T_22[K_28] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_28, "."> extends infer T_32 ? T_32 extends PrefixWith, K_28, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? any : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_29 in keyof T_38]-?: T_38[K_29] extends infer T_39 ? T_39 extends T_38[K_29] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_30 in keyof T_37]-?: T_37[K_30] extends infer T_39 ? T_39 extends T_37[K_30] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_31 in keyof T_36]-?: T_36[K_31] extends infer T_39 ? T_39 extends T_36[K_31] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_32 in keyof T_35]-?: T_35[K_32] extends infer T_39 ? T_39 extends T_35[K_32] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_33 in keyof T_34]-?: T_34[K_33] extends infer T_39 ? T_39 extends T_34[K_33] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_34 in keyof T_33]-?: T_33[K_34] extends infer T_39 ? T_39 extends T_33[K_34] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_35 in keyof T_31]-?: T_31[K_35] extends infer T_39 ? T_39 extends T_31[K_35] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_31 : never : never; } : T_22 : never : never; } : T_12 : never : never; } : T_2 : never : never : T extends (infer U)[] ? any[] : T extends object ? { [K_11 in keyof T]-?: T[K_11] extends infer T_12 ? T_12 extends T[K_11] ? T_12 extends CanBeExpanded ? T_12[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[`${string & K_11}` extends infer T_13 ? T_13 extends `${string & K_11}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_13 in keyof T_22]-?: any; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_14 in keyof T_21]-?: T_21[K_14] extends infer T_23 ? T_23 extends T_21[K_14] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_15 in keyof T_23]-?: any; } : T_23 : never : never; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_15 in keyof T_20]-?: T_20[K_15] extends infer T_23 ? T_23 extends T_20[K_15] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_11}`, K_15, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_15, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_11}`, K_15, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_15, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_16 in keyof T_25]-?: any; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_17 in keyof T_23]-?: T_23[K_17] extends infer T_26 ? T_26 extends T_23[K_17] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_18 in keyof T_26]-?: T_26[K_18] extends infer T_27 ? T_27 extends T_26[K_18] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_23 : never : never; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_16 in keyof T_19]-?: T_19[K_16] extends infer T_23 ? T_23 extends T_19[K_16] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_11}`, K_16, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_16, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_11}`, K_16, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_16, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_11}`, K_16, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_16, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_11}`, K_16, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_16, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_17 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_18 in keyof T_25]-?: T_25[K_18] extends infer T_27 ? T_27 extends T_25[K_18] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_19 in keyof T_27]-?: T_27[K_19] extends infer T_28 ? T_28 extends T_27[K_19] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_19 in keyof T_23]-?: T_23[K_19] extends infer T_27 ? T_27 extends T_23[K_19] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_19, "."> extends infer T_28 ? T_28 extends PrefixWith, K_19, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_19, "."> extends infer T_28 ? T_28 extends PrefixWith, K_19, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_20 in keyof T_29]-?: T_29[K_20] extends infer T_30 ? T_30 extends T_29[K_20] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_21 in keyof T_27]-?: T_27[K_21] extends infer T_30 ? T_30 extends T_27[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_23 : never : never; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_17 in keyof T_18]-?: T_18[K_17] extends infer T_23 ? T_23 extends T_18[K_17] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_11}`, K_17, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_17, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_11}`, K_17, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_17, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_11}`, K_17, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_17, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_11}`, K_17, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_17, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_11}`, K_17, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_17, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_11}`, K_17, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_17, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_18 in keyof T_27]-?: any; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_19 in keyof T_26]-?: T_26[K_19] extends infer T_28 ? T_28 extends T_26[K_19] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_20 in keyof T_28]-?: T_28[K_20] extends infer T_29 ? T_29 extends T_28[K_20] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_20 in keyof T_25]-?: T_25[K_20] extends infer T_28 ? T_28 extends T_25[K_20] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_20, "."> extends infer T_29 ? T_29 extends PrefixWith, K_20, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_20, "."> extends infer T_29 ? T_29 extends PrefixWith, K_20, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_21 in keyof T_30]-?: T_30[K_21] extends infer T_31 ? T_31 extends T_30[K_21] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_22 in keyof T_28]-?: T_28[K_22] extends infer T_31 ? T_31 extends T_28[K_22] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_21 in keyof T_23]-?: T_23[K_21] extends infer T_28 ? T_28 extends T_23[K_21] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_21, "."> extends infer T_29 ? T_29 extends PrefixWith, K_21, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_22 in keyof T_31]-?: T_31[K_22] extends infer T_32 ? T_32 extends T_31[K_22] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_23 in keyof T_30]-?: T_30[K_23] extends infer T_32 ? T_32 extends T_30[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_24 in keyof T_28]-?: T_28[K_24] extends infer T_32 ? T_32 extends T_28[K_24] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_28 : never : never; } : T_23 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_18 in keyof T_17]-?: T_17[K_18] extends infer T_23 ? T_23 extends T_17[K_18] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_11}`, K_18, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_18, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_11}`, K_18, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_18, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_11}`, K_18, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_18, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_11}`, K_18, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_18, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_11}`, K_18, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_18, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_11}`, K_18, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_18, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_11}`, K_18, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_18, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_11}`, K_18, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_18, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_19 in keyof T_28]-?: any; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_20 in keyof T_27]-?: T_27[K_20] extends infer T_29 ? T_29 extends T_27[K_20] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_21 in keyof T_29]-?: T_29[K_21] extends infer T_30 ? T_30 extends T_29[K_21] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_21 in keyof T_26]-?: T_26[K_21] extends infer T_29 ? T_29 extends T_26[K_21] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_21, "."> extends infer T_30 ? T_30 extends PrefixWith, K_21, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_21, "."> extends infer T_30 ? T_30 extends PrefixWith, K_21, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_22 in keyof T_31]-?: T_31[K_22] extends infer T_32 ? T_32 extends T_31[K_22] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_23 in keyof T_29]-?: T_29[K_23] extends infer T_32 ? T_32 extends T_29[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_22 in keyof T_25]-?: T_25[K_22] extends infer T_29 ? T_29 extends T_25[K_22] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_22, "."> extends infer T_30 ? T_30 extends PrefixWith, K_22, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_23 in keyof T_32]-?: T_32[K_23] extends infer T_33 ? T_33 extends T_32[K_23] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_24 in keyof T_31]-?: T_31[K_24] extends infer T_33 ? T_33 extends T_31[K_24] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_25 in keyof T_29]-?: T_29[K_25] extends infer T_33 ? T_33 extends T_29[K_25] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_23 in keyof T_23]-?: T_23[K_23] extends infer T_29 ? T_29 extends T_23[K_23] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_23, "."> extends infer T_30 ? T_30 extends PrefixWith, K_23, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_24 in keyof T_33]-?: T_33[K_24] extends infer T_34 ? T_34 extends T_33[K_24] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_25 in keyof T_32]-?: T_32[K_25] extends infer T_34 ? T_34 extends T_32[K_25] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_26 in keyof T_31]-?: T_31[K_26] extends infer T_34 ? T_34 extends T_31[K_26] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_27 in keyof T_29]-?: T_29[K_27] extends infer T_34 ? T_34 extends T_29[K_27] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_29 : never : never; } : T_23 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_19 in keyof T_16]-?: T_16[K_19] extends infer T_23 ? T_23 extends T_16[K_19] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_11}`, K_19, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_19, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_20 in keyof T_29]-?: any; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_21 in keyof T_28]-?: T_28[K_21] extends infer T_30 ? T_30 extends T_28[K_21] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_22 in keyof T_30]-?: T_30[K_22] extends infer T_31 ? T_31 extends T_30[K_22] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_22 in keyof T_27]-?: T_27[K_22] extends infer T_30 ? T_30 extends T_27[K_22] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_22, "."> extends infer T_31 ? T_31 extends PrefixWith, K_22, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_22, "."> extends infer T_31 ? T_31 extends PrefixWith, K_22, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_23 in keyof T_32]-?: T_32[K_23] extends infer T_33 ? T_33 extends T_32[K_23] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_24 in keyof T_30]-?: T_30[K_24] extends infer T_33 ? T_33 extends T_30[K_24] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_23 in keyof T_26]-?: T_26[K_23] extends infer T_30 ? T_30 extends T_26[K_23] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_23, "."> extends infer T_31 ? T_31 extends PrefixWith, K_23, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_23, "."> extends infer T_31 ? T_31 extends PrefixWith, K_23, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_23, "."> extends infer T_31 ? T_31 extends PrefixWith, K_23, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_23, "."> extends infer T_31 ? T_31 extends PrefixWith, K_23, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_24 in keyof T_33]-?: T_33[K_24] extends infer T_34 ? T_34 extends T_33[K_24] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_25 in keyof T_32]-?: T_32[K_25] extends infer T_34 ? T_34 extends T_32[K_25] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_26 in keyof T_30]-?: T_30[K_26] extends infer T_34 ? T_34 extends T_30[K_26] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_30 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_24 in keyof T_25]-?: T_25[K_24] extends infer T_30 ? T_30 extends T_25[K_24] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_24, "."> extends infer T_31 ? T_31 extends PrefixWith, K_24, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_25 in keyof T_34]-?: T_34[K_25] extends infer T_35 ? T_35 extends T_34[K_25] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_26 in keyof T_33]-?: T_33[K_26] extends infer T_35 ? T_35 extends T_33[K_26] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_27 in keyof T_32]-?: T_32[K_27] extends infer T_35 ? T_35 extends T_32[K_27] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_28 in keyof T_30]-?: T_30[K_28] extends infer T_35 ? T_35 extends T_30[K_28] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_30 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_25 in keyof T_23]-?: T_23[K_25] extends infer T_30 ? T_30 extends T_23[K_25] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_25, "."> extends infer T_31 ? T_31 extends PrefixWith, K_25, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_26 in keyof T_35]-?: T_35[K_26] extends infer T_36 ? T_36 extends T_35[K_26] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_27 in keyof T_34]-?: T_34[K_27] extends infer T_36 ? T_36 extends T_34[K_27] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_28 in keyof T_33]-?: T_33[K_28] extends infer T_36 ? T_36 extends T_33[K_28] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_29 in keyof T_32]-?: T_32[K_29] extends infer T_36 ? T_36 extends T_32[K_29] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_30 in keyof T_30]-?: T_30[K_30] extends infer T_36 ? T_36 extends T_30[K_30] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_30 : never : never; } : T_23 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_20 in keyof T_15]-?: T_15[K_20] extends infer T_23 ? T_23 extends T_15[K_20] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_11}`, K_20, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_20, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_21 in keyof T_30]-?: any; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_22 in keyof T_29]-?: T_29[K_22] extends infer T_31 ? T_31 extends T_29[K_22] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_23 in keyof T_31]-?: T_31[K_23] extends infer T_32 ? T_32 extends T_31[K_23] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_23 in keyof T_28]-?: T_28[K_23] extends infer T_31 ? T_31 extends T_28[K_23] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_23, "."> extends infer T_32 ? T_32 extends PrefixWith, K_23, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_23, "."> extends infer T_32 ? T_32 extends PrefixWith, K_23, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_24 in keyof T_33]-?: T_33[K_24] extends infer T_34 ? T_34 extends T_33[K_24] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_25 in keyof T_31]-?: T_31[K_25] extends infer T_34 ? T_34 extends T_31[K_25] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_24 in keyof T_27]-?: T_27[K_24] extends infer T_31 ? T_31 extends T_27[K_24] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_24, "."> extends infer T_32 ? T_32 extends PrefixWith, K_24, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_24, "."> extends infer T_32 ? T_32 extends PrefixWith, K_24, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_24, "."> extends infer T_32 ? T_32 extends PrefixWith, K_24, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_24, "."> extends infer T_32 ? T_32 extends PrefixWith, K_24, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_25 in keyof T_34]-?: T_34[K_25] extends infer T_35 ? T_35 extends T_34[K_25] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_26 in keyof T_33]-?: T_33[K_26] extends infer T_35 ? T_35 extends T_33[K_26] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_27 in keyof T_31]-?: T_31[K_27] extends infer T_35 ? T_35 extends T_31[K_27] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_25 in keyof T_26]-?: T_26[K_25] extends infer T_31 ? T_31 extends T_26[K_25] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_25, "."> extends infer T_32 ? T_32 extends PrefixWith, K_25, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_26 in keyof T_35]-?: T_35[K_26] extends infer T_36 ? T_36 extends T_35[K_26] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_27 in keyof T_34]-?: T_34[K_27] extends infer T_36 ? T_36 extends T_34[K_27] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_28 in keyof T_33]-?: T_33[K_28] extends infer T_36 ? T_36 extends T_33[K_28] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_29 in keyof T_31]-?: T_31[K_29] extends infer T_36 ? T_36 extends T_31[K_29] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_31 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_26 in keyof T_25]-?: T_25[K_26] extends infer T_31 ? T_31 extends T_25[K_26] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_26, "."> extends infer T_32 ? T_32 extends PrefixWith, K_26, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_27 in keyof T_36]-?: T_36[K_27] extends infer T_37 ? T_37 extends T_36[K_27] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_28 in keyof T_35]-?: T_35[K_28] extends infer T_37 ? T_37 extends T_35[K_28] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_29 in keyof T_34]-?: T_34[K_29] extends infer T_37 ? T_37 extends T_34[K_29] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_30 in keyof T_33]-?: T_33[K_30] extends infer T_37 ? T_37 extends T_33[K_30] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_31 in keyof T_31]-?: T_31[K_31] extends infer T_37 ? T_37 extends T_31[K_31] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_31 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_27 in keyof T_23]-?: T_23[K_27] extends infer T_31 ? T_31 extends T_23[K_27] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_27, "."> extends infer T_32 ? T_32 extends PrefixWith, K_27, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_28 in keyof T_37]-?: T_37[K_28] extends infer T_38 ? T_38 extends T_37[K_28] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_29 in keyof T_36]-?: T_36[K_29] extends infer T_38 ? T_38 extends T_36[K_29] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_30 in keyof T_35]-?: T_35[K_30] extends infer T_38 ? T_38 extends T_35[K_30] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_31 in keyof T_34]-?: T_34[K_31] extends infer T_38 ? T_38 extends T_34[K_31] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_32 in keyof T_33]-?: T_33[K_32] extends infer T_38 ? T_38 extends T_33[K_32] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_33 in keyof T_31]-?: T_31[K_33] extends infer T_38 ? T_38 extends T_31[K_33] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_31 : never : never; } : T_23 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_21 in keyof T_14]-?: T_14[K_21] extends infer T_23 ? T_23 extends T_14[K_21] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith<`${string & K_11}`, K_21, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_21, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_22 in keyof T_31]-?: any; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_23 in keyof T_30]-?: T_30[K_23] extends infer T_32 ? T_32 extends T_30[K_23] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_24 in keyof T_32]-?: T_32[K_24] extends infer T_33 ? T_33 extends T_32[K_24] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_24 in keyof T_29]-?: T_29[K_24] extends infer T_32 ? T_32 extends T_29[K_24] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_24, "."> extends infer T_33 ? T_33 extends PrefixWith, K_24, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_24, "."> extends infer T_33 ? T_33 extends PrefixWith, K_24, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_25 in keyof T_34]-?: T_34[K_25] extends infer T_35 ? T_35 extends T_34[K_25] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_26 in keyof T_32]-?: T_32[K_26] extends infer T_35 ? T_35 extends T_32[K_26] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_25 in keyof T_28]-?: T_28[K_25] extends infer T_32 ? T_32 extends T_28[K_25] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_25, "."> extends infer T_33 ? T_33 extends PrefixWith, K_25, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_25, "."> extends infer T_33 ? T_33 extends PrefixWith, K_25, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_25, "."> extends infer T_33 ? T_33 extends PrefixWith, K_25, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_25, "."> extends infer T_33 ? T_33 extends PrefixWith, K_25, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_26 in keyof T_35]-?: T_35[K_26] extends infer T_36 ? T_36 extends T_35[K_26] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_27 in keyof T_34]-?: T_34[K_27] extends infer T_36 ? T_36 extends T_34[K_27] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_28 in keyof T_32]-?: T_32[K_28] extends infer T_36 ? T_36 extends T_32[K_28] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_26 in keyof T_27]-?: T_27[K_26] extends infer T_32 ? T_32 extends T_27[K_26] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_26, "."> extends infer T_33 ? T_33 extends PrefixWith, K_26, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_26, "."> extends infer T_33 ? T_33 extends PrefixWith, K_26, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_26, "."> extends infer T_33 ? T_33 extends PrefixWith, K_26, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_26, "."> extends infer T_33 ? T_33 extends PrefixWith, K_26, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_26, "."> extends infer T_33 ? T_33 extends PrefixWith, K_26, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_26, "."> extends infer T_33 ? T_33 extends PrefixWith, K_26, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_27 in keyof T_36]-?: T_36[K_27] extends infer T_37 ? T_37 extends T_36[K_27] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_28 in keyof T_35]-?: T_35[K_28] extends infer T_37 ? T_37 extends T_35[K_28] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_29 in keyof T_34]-?: T_34[K_29] extends infer T_37 ? T_37 extends T_34[K_29] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_30 in keyof T_32]-?: T_32[K_30] extends infer T_37 ? T_37 extends T_32[K_30] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_32 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_27 in keyof T_26]-?: T_26[K_27] extends infer T_32 ? T_32 extends T_26[K_27] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_27, "."> extends infer T_33 ? T_33 extends PrefixWith, K_27, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_27, "."> extends infer T_33 ? T_33 extends PrefixWith, K_27, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_27, "."> extends infer T_33 ? T_33 extends PrefixWith, K_27, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_27, "."> extends infer T_33 ? T_33 extends PrefixWith, K_27, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_27, "."> extends infer T_33 ? T_33 extends PrefixWith, K_27, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_27, "."> extends infer T_33 ? T_33 extends PrefixWith, K_27, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_27, "."> extends infer T_33 ? T_33 extends PrefixWith, K_27, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_27, "."> extends infer T_33 ? T_33 extends PrefixWith, K_27, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_28 in keyof T_37]-?: T_37[K_28] extends infer T_38 ? T_38 extends T_37[K_28] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_29 in keyof T_36]-?: T_36[K_29] extends infer T_38 ? T_38 extends T_36[K_29] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_30 in keyof T_35]-?: T_35[K_30] extends infer T_38 ? T_38 extends T_35[K_30] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_31 in keyof T_34]-?: T_34[K_31] extends infer T_38 ? T_38 extends T_34[K_31] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_32 in keyof T_32]-?: T_32[K_32] extends infer T_38 ? T_38 extends T_32[K_32] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_32 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_28 in keyof T_25]-?: T_25[K_28] extends infer T_32 ? T_32 extends T_25[K_28] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_28, "."> extends infer T_33 ? T_33 extends PrefixWith, K_28, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? any : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_29 in keyof T_38]-?: T_38[K_29] extends infer T_39 ? T_39 extends T_38[K_29] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_30 in keyof T_37]-?: T_37[K_30] extends infer T_39 ? T_39 extends T_37[K_30] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_31 in keyof T_36]-?: T_36[K_31] extends infer T_39 ? T_39 extends T_36[K_31] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_32 in keyof T_35]-?: T_35[K_32] extends infer T_39 ? T_39 extends T_35[K_32] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_33 in keyof T_34]-?: T_34[K_33] extends infer T_39 ? T_39 extends T_34[K_33] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_34 in keyof T_32]-?: T_32[K_34] extends infer T_39 ? T_39 extends T_32[K_34] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_32 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_29 in keyof T_23]-?: T_23[K_29] extends infer T_32 ? T_32 extends T_23[K_29] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_29, "."> extends infer T_33 ? T_33 extends PrefixWith, K_29, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? any : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_30 in keyof T_39]-?: T_39[K_30] extends infer T_40 ? T_40 extends T_39[K_30] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_31 in keyof T_38]-?: T_38[K_31] extends infer T_40 ? T_40 extends T_38[K_31] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_32 in keyof T_37]-?: T_37[K_32] extends infer T_40 ? T_40 extends T_37[K_32] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_33 in keyof T_36]-?: T_36[K_33] extends infer T_40 ? T_40 extends T_36[K_33] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_34 in keyof T_35]-?: T_35[K_34] extends infer T_40 ? T_40 extends T_35[K_34] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_35 in keyof T_34]-?: T_34[K_35] extends infer T_40 ? T_40 extends T_34[K_35] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_36 in keyof T_32]-?: T_32[K_36] extends infer T_40 ? T_40 extends T_32[K_36] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_32 : never : never; } : T_23 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_22 in keyof T_12]-?: T_12[K_22] extends infer T_23 ? T_23 extends T_12[K_22] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith<`${string & K_11}`, K_22, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_11}`, K_22, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_23 in keyof T_32]-?: any; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_24 in keyof T_31]-?: T_31[K_24] extends infer T_33 ? T_33 extends T_31[K_24] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_25 in keyof T_33]-?: T_33[K_25] extends infer T_34 ? T_34 extends T_33[K_25] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_25 in keyof T_30]-?: T_30[K_25] extends infer T_33 ? T_33 extends T_30[K_25] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_25, "."> extends infer T_34 ? T_34 extends PrefixWith, K_25, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_25, "."> extends infer T_34 ? T_34 extends PrefixWith, K_25, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_26 in keyof T_35]-?: T_35[K_26] extends infer T_36 ? T_36 extends T_35[K_26] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_27 in keyof T_33]-?: T_33[K_27] extends infer T_36 ? T_36 extends T_33[K_27] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_26 in keyof T_29]-?: T_29[K_26] extends infer T_33 ? T_33 extends T_29[K_26] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_26, "."> extends infer T_34 ? T_34 extends PrefixWith, K_26, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_26, "."> extends infer T_34 ? T_34 extends PrefixWith, K_26, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_26, "."> extends infer T_34 ? T_34 extends PrefixWith, K_26, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_26, "."> extends infer T_34 ? T_34 extends PrefixWith, K_26, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_27 in keyof T_36]-?: T_36[K_27] extends infer T_37 ? T_37 extends T_36[K_27] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_28 in keyof T_35]-?: T_35[K_28] extends infer T_37 ? T_37 extends T_35[K_28] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_29 in keyof T_33]-?: T_33[K_29] extends infer T_37 ? T_37 extends T_33[K_29] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_27 in keyof T_28]-?: T_28[K_27] extends infer T_33 ? T_33 extends T_28[K_27] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_27, "."> extends infer T_34 ? T_34 extends PrefixWith, K_27, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_27, "."> extends infer T_34 ? T_34 extends PrefixWith, K_27, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_27, "."> extends infer T_34 ? T_34 extends PrefixWith, K_27, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_27, "."> extends infer T_34 ? T_34 extends PrefixWith, K_27, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_27, "."> extends infer T_34 ? T_34 extends PrefixWith, K_27, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_27, "."> extends infer T_34 ? T_34 extends PrefixWith, K_27, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_28 in keyof T_37]-?: T_37[K_28] extends infer T_38 ? T_38 extends T_37[K_28] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_29 in keyof T_36]-?: T_36[K_29] extends infer T_38 ? T_38 extends T_36[K_29] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_30 in keyof T_35]-?: T_35[K_30] extends infer T_38 ? T_38 extends T_35[K_30] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_31 in keyof T_33]-?: T_33[K_31] extends infer T_38 ? T_38 extends T_33[K_31] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_33 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_28 in keyof T_27]-?: T_27[K_28] extends infer T_33 ? T_33 extends T_27[K_28] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_28, "."> extends infer T_34 ? T_34 extends PrefixWith, K_28, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_28, "."> extends infer T_34 ? T_34 extends PrefixWith, K_28, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_28, "."> extends infer T_34 ? T_34 extends PrefixWith, K_28, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_28, "."> extends infer T_34 ? T_34 extends PrefixWith, K_28, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_28, "."> extends infer T_34 ? T_34 extends PrefixWith, K_28, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_28, "."> extends infer T_34 ? T_34 extends PrefixWith, K_28, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_28, "."> extends infer T_34 ? T_34 extends PrefixWith, K_28, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_28, "."> extends infer T_34 ? T_34 extends PrefixWith, K_28, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? any : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_29 in keyof T_38]-?: T_38[K_29] extends infer T_39 ? T_39 extends T_38[K_29] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_30 in keyof T_37]-?: T_37[K_30] extends infer T_39 ? T_39 extends T_37[K_30] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_31 in keyof T_36]-?: T_36[K_31] extends infer T_39 ? T_39 extends T_36[K_31] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_32 in keyof T_35]-?: T_35[K_32] extends infer T_39 ? T_39 extends T_35[K_32] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_33 in keyof T_33]-?: T_33[K_33] extends infer T_39 ? T_39 extends T_33[K_33] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_33 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_29 in keyof T_26]-?: T_26[K_29] extends infer T_33 ? T_33 extends T_26[K_29] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_29, "."> extends infer T_34 ? T_34 extends PrefixWith, K_29, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? any : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_30 in keyof T_39]-?: T_39[K_30] extends infer T_40 ? T_40 extends T_39[K_30] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_31 in keyof T_38]-?: T_38[K_31] extends infer T_40 ? T_40 extends T_38[K_31] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_32 in keyof T_37]-?: T_37[K_32] extends infer T_40 ? T_40 extends T_37[K_32] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_33 in keyof T_36]-?: T_36[K_33] extends infer T_40 ? T_40 extends T_36[K_33] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_34 in keyof T_35]-?: T_35[K_34] extends infer T_40 ? T_40 extends T_35[K_34] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_35 in keyof T_33]-?: T_33[K_35] extends infer T_40 ? T_40 extends T_33[K_35] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_33 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_30 in keyof T_25]-?: T_25[K_30] extends infer T_33 ? T_33 extends T_25[K_30] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? T_39[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_40 ? T_40 extends T_39[PrefixWith, K_30, "."> extends infer T_34 ? T_34 extends PrefixWith, K_30, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_40 extends CanBeExpanded ? any : T_40 extends (infer U)[] ? any[] : T_40 extends object ? { [K_31 in keyof T_40]-?: T_40[K_31] extends infer T_41 ? T_41 extends T_40[K_31] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_40 : never : never : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_32 in keyof T_39]-?: T_39[K_32] extends infer T_41 ? T_41 extends T_39[K_32] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_33 in keyof T_38]-?: T_38[K_33] extends infer T_41 ? T_41 extends T_38[K_33] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_34 in keyof T_37]-?: T_37[K_34] extends infer T_41 ? T_41 extends T_37[K_34] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_35 in keyof T_36]-?: T_36[K_35] extends infer T_41 ? T_41 extends T_36[K_35] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_36 in keyof T_35]-?: T_35[K_36] extends infer T_41 ? T_41 extends T_35[K_36] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_37 in keyof T_33]-?: T_33[K_37] extends infer T_41 ? T_41 extends T_33[K_37] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_33 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_31 in keyof T_23]-?: T_23[K_31] extends infer T_33 ? T_33 extends T_23[K_31] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? T_39[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_40 ? T_40 extends T_39[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_40 extends CanBeExpanded ? T_40[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_41 ? T_41 extends T_40[PrefixWith, K_31, "."> extends infer T_34 ? T_34 extends PrefixWith, K_31, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_41 extends CanBeExpanded ? any : T_41 extends (infer U)[] ? any[] : T_41 extends object ? { [K_32 in keyof T_41]-?: T_41[K_32] extends infer T_42 ? T_42 extends T_41[K_32] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_41 : never : never : T_40 extends (infer U)[] ? any[] : T_40 extends object ? { [K_33 in keyof T_40]-?: T_40[K_33] extends infer T_42 ? T_42 extends T_40[K_33] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_40 : never : never : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_34 in keyof T_39]-?: T_39[K_34] extends infer T_42 ? T_42 extends T_39[K_34] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_35 in keyof T_38]-?: T_38[K_35] extends infer T_42 ? T_42 extends T_38[K_35] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_36 in keyof T_37]-?: T_37[K_36] extends infer T_42 ? T_42 extends T_37[K_36] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_37 in keyof T_36]-?: T_36[K_37] extends infer T_42 ? T_42 extends T_36[K_37] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_38 in keyof T_35]-?: T_35[K_38] extends infer T_42 ? T_42 extends T_35[K_38] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_39 in keyof T_33]-?: T_33[K_39] extends infer T_42 ? T_42 extends T_33[K_39] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_33 : never : never; } : T_23 : never : never; } : T_12 : never : never; } : T -+>UseQueryOptions2 : T extends CanBeExpanded ? T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_2 ? T_2 extends T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_2 extends CanBeExpanded ? T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_3 ? T_3 extends T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_3 extends CanBeExpanded ? T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_1]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: any; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_3 extends (infer U)[] ? any[] : T_3 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? any : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: any; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: any; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_3 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10[`${string & K_1}` extends infer T_3 ? T_3 extends `${string & K_1}` ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_1]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: any; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? any : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: any; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never : T extends (infer U)[] ? any[] : T extends object ? { [K_1 in keyof T]-?: T[K_1] extends infer T_1 ? T_1 extends T[K_1] ? T_1 extends CanBeExpanded ? T_1[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_3 ? T_3 extends T_1[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_3 extends CanBeExpanded ? T_3[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_3[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10[`${string & K_1}` extends infer T_2 ? T_2 extends `${string & K_1}` ? T_2 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_1]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: any; } : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: any; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: any; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: any; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: any; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: any; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: any; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_3 extends (infer U)[] ? any[] : T_3 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? any : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: any; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_3 : never : never : T_1 extends (infer U)[] ? any[] : T_1 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10[PrefixWith<`${string & K_2}`, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith<`${string & K_2}`, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_1]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? any : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? any : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? any : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? any : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? any : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? any : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? any : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_2[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9[PrefixWith, K_1, "."> extends infer T_3 ? T_3 extends PrefixWith, K_1, "."> ? T_3 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? any : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_4 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_1]-?: T_1[K_1] extends infer T_2 ? T_2 extends T_1[K_1] ? T_2 extends CanBeExpanded ? T_2["default"] : T_2 : never : never; } : T_2 : never : never; } : T_2 : never : never; } : T_1 : never : never; } : T ++>UseQueryOptions2 : T extends CanBeExpanded ? T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_2 ? T_2 extends T["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_2 extends CanBeExpanded ? T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_3 ? T_3 extends T_2["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_3 extends CanBeExpanded ? T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_4 ? T_4 extends T_3["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_4 extends CanBeExpanded ? T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_5 ? T_5 extends T_4["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_5 extends CanBeExpanded ? T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_6 ? T_6 extends T_5["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_6 extends CanBeExpanded ? T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_7 ? T_7 extends T_6["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_7 extends CanBeExpanded ? T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_8 ? T_8 extends T_7["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_8 extends CanBeExpanded ? T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_9 ? T_9 extends T_8["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_9 extends CanBeExpanded ? T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_10 ? T_10 extends T_9["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_10 extends CanBeExpanded ? T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] extends infer T_11 ? T_11 extends T_10["" extends infer T_1 ? T_1 extends "" ? T_1 extends SplitAC ? "value" : "default" : never : never] ? T_11 extends CanBeExpanded ? any : T_11 extends (infer U)[] ? any[] : T_11 extends object ? { [K_1 in keyof T_11]-?: any; } : T_11 : never : never : T_10 extends (infer U)[] ? any[] : T_10 extends object ? { [K_1 in keyof T_10]-?: T_10[K_1] extends infer T_12 ? T_12 extends T_10[K_1] ? T_12 extends CanBeExpanded ? any : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: any; } : T_12 : never : never; } : T_10 : never : never : T_9 extends (infer U)[] ? any[] : T_9 extends object ? { [K_1 in keyof T_9]-?: T_9[K_1] extends infer T_12 ? T_12 extends T_9[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? any : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: any; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_15 ? T_15 extends T_12[K_2] ? T_15 extends CanBeExpanded ? any : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_3 in keyof T_15]-?: any; } : T_15 : never : never; } : T_12 : never : never; } : T_9 : never : never : T_8 extends (infer U)[] ? any[] : T_8 extends object ? { [K_1 in keyof T_8]-?: T_8[K_1] extends infer T_12 ? T_12 extends T_8[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? any : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: any; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_16 ? T_16 extends T_14[K_2] ? T_16 extends CanBeExpanded ? any : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_3 in keyof T_16]-?: any; } : T_16 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_16 ? T_16 extends T_12[K_2] ? T_16 extends CanBeExpanded ? T_16[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_17 ? T_17 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_17 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_16[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_17 ? T_17 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_17 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? any : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: any; } : T_18 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_3 in keyof T_16]-?: T_16[K_3] extends infer T_19 ? T_19 extends T_16[K_3] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_4 in keyof T_19]-?: T_19[K_4] extends infer T_20 ? T_20 extends T_19[K_4] ? T_20 extends CanBeExpanded ? T_20["default"] : T_20 : never : never; } : T_19 : never : never; } : T_16 : never : never; } : T_12 : never : never; } : T_8 : never : never : T_7 extends (infer U)[] ? any[] : T_7 extends object ? { [K_1 in keyof T_7]-?: T_7[K_1] extends infer T_12 ? T_12 extends T_7[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? any : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: any; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_17 ? T_17 extends T_15[K_2] ? T_17 extends CanBeExpanded ? any : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_3 in keyof T_17]-?: any; } : T_17 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_17 ? T_17 extends T_14[K_2] ? T_17 extends CanBeExpanded ? T_17[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_17[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: any; } : T_19 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_3 in keyof T_17]-?: T_17[K_3] extends infer T_20 ? T_20 extends T_17[K_3] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_4 in keyof T_20]-?: T_20[K_4] extends infer T_21 ? T_21 extends T_20[K_4] ? T_21 extends CanBeExpanded ? T_21["default"] : T_21 : never : never; } : T_20 : never : never; } : T_17 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_17 ? T_17 extends T_12[K_2] ? T_17 extends CanBeExpanded ? T_17[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_17[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_18 ? T_18 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_18 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: any; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_21 ? T_21 extends T_19[K_3] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_4 in keyof T_21]-?: T_21[K_4] extends infer T_22 ? T_22 extends T_21[K_4] ? T_22 extends CanBeExpanded ? T_22["default"] : T_22 : never : never; } : T_21 : never : never; } : T_19 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_3 in keyof T_17]-?: T_17[K_3] extends infer T_21 ? T_21 extends T_17[K_3] ? T_21 extends CanBeExpanded ? T_21[PrefixWith, K_3, "."> extends infer T_22 ? T_22 extends PrefixWith, K_3, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith, K_3, "."> extends infer T_22 ? T_22 extends PrefixWith, K_3, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_24 ? T_24 extends T_23[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_4 in keyof T_21]-?: T_21[K_4] extends infer T_24 ? T_24 extends T_21[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_21 : never : never; } : T_17 : never : never; } : T_12 : never : never; } : T_7 : never : never : T_6 extends (infer U)[] ? any[] : T_6 extends object ? { [K_1 in keyof T_6]-?: T_6[K_1] extends infer T_12 ? T_12 extends T_6[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? any : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: any; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_18 ? T_18 extends T_16[K_2] ? T_18 extends CanBeExpanded ? any : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: any; } : T_18 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_18 ? T_18 extends T_15[K_2] ? T_18 extends CanBeExpanded ? T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: any; } : T_20 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: T_18[K_3] extends infer T_21 ? T_21 extends T_18[K_3] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_4 in keyof T_21]-?: T_21[K_4] extends infer T_22 ? T_22 extends T_21[K_4] ? T_22 extends CanBeExpanded ? T_22["default"] : T_22 : never : never; } : T_21 : never : never; } : T_18 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_18 ? T_18 extends T_14[K_2] ? T_18 extends CanBeExpanded ? T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: any; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_22 ? T_22 extends T_20[K_3] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_4 in keyof T_22]-?: T_22[K_4] extends infer T_23 ? T_23 extends T_22[K_4] ? T_23 extends CanBeExpanded ? T_23["default"] : T_23 : never : never; } : T_22 : never : never; } : T_20 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: T_18[K_3] extends infer T_22 ? T_22 extends T_18[K_3] ? T_22 extends CanBeExpanded ? T_22[PrefixWith, K_3, "."> extends infer T_23 ? T_23 extends PrefixWith, K_3, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith, K_3, "."> extends infer T_23 ? T_23 extends PrefixWith, K_3, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_25 ? T_25 extends T_24[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_4 in keyof T_22]-?: T_22[K_4] extends infer T_25 ? T_25 extends T_22[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_22 : never : never; } : T_18 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_18 ? T_18 extends T_12[K_2] ? T_18 extends CanBeExpanded ? T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_18[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_19 ? T_19 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_19 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: any; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_23 ? T_23 extends T_21[K_3] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_24 ? T_24 extends T_23[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_23 ? T_23 extends T_20[K_3] ? T_23 extends CanBeExpanded ? T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_26 ? T_26 extends T_23[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_23 : never : never; } : T_20 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_3 in keyof T_18]-?: T_18[K_3] extends infer T_23 ? T_23 extends T_18[K_3] ? T_23 extends CanBeExpanded ? T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_27 ? T_27 extends T_25[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_27 ? T_27 extends T_23[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_23 : never : never; } : T_18 : never : never; } : T_12 : never : never; } : T_6 : never : never : T_5 extends (infer U)[] ? any[] : T_5 extends object ? { [K_1 in keyof T_5]-?: T_5[K_1] extends infer T_12 ? T_12 extends T_5[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? any : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: any; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_19 ? T_19 extends T_17[K_2] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: any; } : T_19 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_19 ? T_19 extends T_16[K_2] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: any; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_22 ? T_22 extends T_19[K_3] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_4 in keyof T_22]-?: T_22[K_4] extends infer T_23 ? T_23 extends T_22[K_4] ? T_23 extends CanBeExpanded ? T_23["default"] : T_23 : never : never; } : T_22 : never : never; } : T_19 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_19 ? T_19 extends T_15[K_2] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: any; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_23 ? T_23 extends T_21[K_3] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_24 ? T_24 extends T_23[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_23 ? T_23 extends T_19[K_3] ? T_23 extends CanBeExpanded ? T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith, K_3, "."> extends infer T_24 ? T_24 extends PrefixWith, K_3, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_26 ? T_26 extends T_23[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_23 : never : never; } : T_19 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_19 ? T_19 extends T_14[K_2] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: any; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_24 ? T_24 extends T_22[K_3] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_25 ? T_25 extends T_24[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_24 ? T_24 extends T_21[K_3] ? T_24 extends CanBeExpanded ? T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_27 ? T_27 extends T_24[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_24 : never : never; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_24 ? T_24 extends T_19[K_3] ? T_24 extends CanBeExpanded ? T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_28 ? T_28 extends T_26[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_26 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_28 ? T_28 extends T_24[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_24 : never : never; } : T_19 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_19 ? T_19 extends T_12[K_2] ? T_19 extends CanBeExpanded ? T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_19[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_20 ? T_20 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_20 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: any; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_25 ? T_25 extends T_23[K_3] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_25 ? T_25 extends T_22[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_28 ? T_28 extends T_25[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_25 : never : never; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_25 ? T_25 extends T_21[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_29 ? T_29 extends T_27[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_29 ? T_29 extends T_25[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_25 : never : never; } : T_21 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_3 in keyof T_19]-?: T_19[K_3] extends infer T_25 ? T_25 extends T_19[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_30 ? T_30 extends T_28[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_30 ? T_30 extends T_25[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_25 : never : never; } : T_19 : never : never; } : T_12 : never : never; } : T_5 : never : never : T_4 extends (infer U)[] ? any[] : T_4 extends object ? { [K_1 in keyof T_4]-?: T_4[K_1] extends infer T_12 ? T_12 extends T_4[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? any : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_2 in keyof T_19]-?: any; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: T_18[K_2] extends infer T_20 ? T_20 extends T_18[K_2] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: any; } : T_20 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_20 ? T_20 extends T_17[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: any; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_23 ? T_23 extends T_20[K_3] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_4 in keyof T_23]-?: T_23[K_4] extends infer T_24 ? T_24 extends T_23[K_4] ? T_24 extends CanBeExpanded ? T_24["default"] : T_24 : never : never; } : T_23 : never : never; } : T_20 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_20 ? T_20 extends T_16[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: any; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_24 ? T_24 extends T_22[K_3] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_25 ? T_25 extends T_24[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_24 ? T_24 extends T_20[K_3] ? T_24 extends CanBeExpanded ? T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_24[PrefixWith, K_3, "."> extends infer T_25 ? T_25 extends PrefixWith, K_3, "."> ? T_25 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_27 ? T_27 extends T_24[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_24 : never : never; } : T_20 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_20 ? T_20 extends T_15[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: any; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_25 ? T_25 extends T_23[K_3] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_25 ? T_25 extends T_22[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_28 ? T_28 extends T_25[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_25 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_25 ? T_25 extends T_20[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_29 ? T_29 extends T_27[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_29 ? T_29 extends T_25[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_25 : never : never; } : T_20 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_20 ? T_20 extends T_14[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: any; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_26 ? T_26 extends T_24[K_3] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_26 ? T_26 extends T_23[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_29 ? T_29 extends T_26[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_26 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_26 ? T_26 extends T_22[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_30 ? T_30 extends T_28[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_30 ? T_30 extends T_26[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_26 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_26 ? T_26 extends T_20[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_31 ? T_31 extends T_29[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_31 ? T_31 extends T_28[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_31 ? T_31 extends T_26[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_26 : never : never; } : T_20 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_20 ? T_20 extends T_12[K_2] ? T_20 extends CanBeExpanded ? T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_20[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_21 ? T_21 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_21 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_27 ? T_27 extends T_25[K_3] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_27 ? T_27 extends T_24[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_27 ? T_27 extends T_23[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_31 ? T_31 extends T_29[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_31 ? T_31 extends T_27[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_27 : never : never; } : T_23 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_27 ? T_27 extends T_22[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_32 ? T_32 extends T_27[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_27 : never : never; } : T_22 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_3 in keyof T_20]-?: T_20[K_3] extends infer T_27 ? T_27 extends T_20[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_33 ? T_33 extends T_29[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_33 ? T_33 extends T_27[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_27 : never : never; } : T_20 : never : never; } : T_12 : never : never; } : T_4 : never : never : T_3 extends (infer U)[] ? any[] : T_3 extends object ? { [K_1 in keyof T_3]-?: T_3[K_1] extends infer T_12 ? T_12 extends T_3[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? any : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_2 in keyof T_20]-?: any; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_2 in keyof T_19]-?: T_19[K_2] extends infer T_21 ? T_21 extends T_19[K_2] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: any; } : T_21 : never : never; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: T_18[K_2] extends infer T_21 ? T_21 extends T_18[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: any; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_24 ? T_24 extends T_21[K_3] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_4 in keyof T_24]-?: T_24[K_4] extends infer T_25 ? T_25 extends T_24[K_4] ? T_25 extends CanBeExpanded ? T_25["default"] : T_25 : never : never; } : T_24 : never : never; } : T_21 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_21 ? T_21 extends T_17[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: any; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_25 ? T_25 extends T_23[K_3] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_25 ? T_25 extends T_21[K_3] ? T_25 extends CanBeExpanded ? T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_25[PrefixWith, K_3, "."> extends infer T_26 ? T_26 extends PrefixWith, K_3, "."> ? T_26 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_28 ? T_28 extends T_25[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_25 : never : never; } : T_21 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_21 ? T_21 extends T_16[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: any; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_26 ? T_26 extends T_24[K_3] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_26 ? T_26 extends T_23[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_29 ? T_29 extends T_26[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_26 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_26 ? T_26 extends T_21[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_30 ? T_30 extends T_28[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_30 ? T_30 extends T_26[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_26 : never : never; } : T_21 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_21 ? T_21 extends T_15[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_27 ? T_27 extends T_25[K_3] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_27 ? T_27 extends T_24[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_27 ? T_27 extends T_23[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_31 ? T_31 extends T_29[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_31 ? T_31 extends T_27[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_27 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_27 ? T_27 extends T_21[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_32 ? T_32 extends T_27[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_27 : never : never; } : T_21 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_21 ? T_21 extends T_14[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: any; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_28 ? T_28 extends T_26[K_3] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_28 ? T_28 extends T_25[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_31 ? T_31 extends T_28[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_28 ? T_28 extends T_24[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_32 ? T_32 extends T_28[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_28 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_28 ? T_28 extends T_23[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_33 ? T_33 extends T_28[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_28 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_28 ? T_28 extends T_21[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_34 ? T_34 extends T_30[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_34 ? T_34 extends T_28[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_28 : never : never; } : T_21 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_21 ? T_21 extends T_12[K_2] ? T_21 extends CanBeExpanded ? T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_23 ? T_23 extends T_21[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_22 ? T_22 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_22 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: any; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_29 ? T_29 extends T_27[K_3] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_29 ? T_29 extends T_26[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_29 ? T_29 extends T_25[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_33 ? T_33 extends T_29[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_29 ? T_29 extends T_24[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_34 ? T_34 extends T_29[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_29 : never : never; } : T_24 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_29 ? T_29 extends T_23[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_35 ? T_35 extends T_31[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_35 ? T_35 extends T_29[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_29 : never : never; } : T_23 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_3 in keyof T_21]-?: T_21[K_3] extends infer T_29 ? T_29 extends T_21[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_36 ? T_36 extends T_32[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_36 ? T_36 extends T_31[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_36 ? T_36 extends T_29[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_29 : never : never; } : T_21 : never : never; } : T_12 : never : never; } : T_3 : never : never : T_2 extends (infer U)[] ? any[] : T_2 extends object ? { [K_1 in keyof T_2]-?: T_2[K_1] extends infer T_12 ? T_12 extends T_2[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? any : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_2 in keyof T_21]-?: any; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_2 in keyof T_20]-?: T_20[K_2] extends infer T_22 ? T_22 extends T_20[K_2] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: any; } : T_22 : never : never; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_2 in keyof T_19]-?: T_19[K_2] extends infer T_22 ? T_22 extends T_19[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? any : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: any; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_25 ? T_25 extends T_22[K_3] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_4 in keyof T_25]-?: T_25[K_4] extends infer T_26 ? T_26 extends T_25[K_4] ? T_26 extends CanBeExpanded ? T_26["default"] : T_26 : never : never; } : T_25 : never : never; } : T_22 : never : never; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: T_18[K_2] extends infer T_22 ? T_22 extends T_18[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: any; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_26 ? T_26 extends T_24[K_3] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_26 ? T_26 extends T_22[K_3] ? T_26 extends CanBeExpanded ? T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_26[PrefixWith, K_3, "."> extends infer T_27 ? T_27 extends PrefixWith, K_3, "."> ? T_27 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_29 ? T_29 extends T_26[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_26 : never : never; } : T_22 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_22 ? T_22 extends T_17[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_27 ? T_27 extends T_25[K_3] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_27 ? T_27 extends T_24[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_27 ? T_27 extends T_22[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_31 ? T_31 extends T_29[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_31 ? T_31 extends T_27[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_27 : never : never; } : T_22 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_22 ? T_22 extends T_16[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: any; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_28 ? T_28 extends T_26[K_3] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_28 ? T_28 extends T_25[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_31 ? T_31 extends T_28[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_28 ? T_28 extends T_24[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_32 ? T_32 extends T_28[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_28 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_28 ? T_28 extends T_22[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_33 ? T_33 extends T_28[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_28 : never : never; } : T_22 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_22 ? T_22 extends T_15[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: any; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_29 ? T_29 extends T_27[K_3] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_29 ? T_29 extends T_26[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_29 ? T_29 extends T_25[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_33 ? T_33 extends T_29[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_29 ? T_29 extends T_24[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_34 ? T_34 extends T_29[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_29 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_29 ? T_29 extends T_22[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_35 ? T_35 extends T_31[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_35 ? T_35 extends T_29[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_29 : never : never; } : T_22 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_22 ? T_22 extends T_14[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: any; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_30 ? T_30 extends T_28[K_3] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_30 ? T_30 extends T_27[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_30 ? T_30 extends T_26[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_34 ? T_34 extends T_30[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_30 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_30 ? T_30 extends T_25[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_35 ? T_35 extends T_30[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_30 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_30 ? T_30 extends T_24[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_36 ? T_36 extends T_32[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_36 ? T_36 extends T_30[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_30 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_30 ? T_30 extends T_22[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_37 ? T_37 extends T_34[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_37 ? T_37 extends T_33[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_37 ? T_37 extends T_32[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_37 ? T_37 extends T_30[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_30 : never : never; } : T_22 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_22 ? T_22 extends T_12[K_2] ? T_22 extends CanBeExpanded ? T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_24 ? T_24 extends T_22[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_24 extends CanBeExpanded ? T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_24[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_23 ? T_23 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_23 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_3 in keyof T_30]-?: any; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: T_29[K_3] extends infer T_31 ? T_31 extends T_29[K_3] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_31 ? T_31 extends T_28[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_31 ? T_31 extends T_27[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_35 ? T_35 extends T_31[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_31 ? T_31 extends T_26[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_36 ? T_36 extends T_31[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_31 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_31 ? T_31 extends T_25[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_37 ? T_37 extends T_34[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_37 ? T_37 extends T_33[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_37 ? T_37 extends T_31[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_31 : never : never; } : T_25 : never : never : T_24 extends (infer U)[] ? any[] : T_24 extends object ? { [K_3 in keyof T_24]-?: T_24[K_3] extends infer T_31 ? T_31 extends T_24[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_38 ? T_38 extends T_37[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_38 ? T_38 extends T_36[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_38 ? T_38 extends T_35[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_38 ? T_38 extends T_34[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_38 ? T_38 extends T_33[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_38 ? T_38 extends T_31[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_31 : never : never; } : T_24 : never : never : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_3 in keyof T_22]-?: T_22[K_3] extends infer T_31 ? T_31 extends T_22[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? any : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_39 ? T_39 extends T_38[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_39 ? T_39 extends T_37[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_39 ? T_39 extends T_36[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_39 ? T_39 extends T_35[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_39 ? T_39 extends T_34[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_39 ? T_39 extends T_33[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_39 ? T_39 extends T_31[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_31 : never : never; } : T_22 : never : never; } : T_12 : never : never; } : T_2 : never : never : T extends (infer U)[] ? any[] : T extends object ? { [K_1 in keyof T]-?: T[K_1] extends infer T_12 ? T_12 extends T[K_1] ? T_12 extends CanBeExpanded ? T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_14 ? T_14 extends T_12[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_14 extends CanBeExpanded ? T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_15 ? T_15 extends T_14[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_15 extends CanBeExpanded ? T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_16 ? T_16 extends T_15[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_16 extends CanBeExpanded ? T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_17 ? T_17 extends T_16[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_17 extends CanBeExpanded ? T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_18 ? T_18 extends T_17[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_18 extends CanBeExpanded ? T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_19 ? T_19 extends T_18[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_19 extends CanBeExpanded ? T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_20 ? T_20 extends T_19[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_20 extends CanBeExpanded ? T_20[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_21 ? T_21 extends T_20[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_21 extends CanBeExpanded ? T_21[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] extends infer T_22 ? T_22 extends T_21[`${string & K_1}` extends infer T_13 ? T_13 extends `${string & K_1}` ? T_13 extends SplitAC ? "value" : "default" : never : never] ? T_22 extends CanBeExpanded ? any : T_22 extends (infer U)[] ? any[] : T_22 extends object ? { [K_2 in keyof T_22]-?: any; } : T_22 : never : never : T_21 extends (infer U)[] ? any[] : T_21 extends object ? { [K_2 in keyof T_21]-?: T_21[K_2] extends infer T_23 ? T_23 extends T_21[K_2] ? T_23 extends CanBeExpanded ? any : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: any; } : T_23 : never : never; } : T_21 : never : never : T_20 extends (infer U)[] ? any[] : T_20 extends object ? { [K_2 in keyof T_20]-?: T_20[K_2] extends infer T_23 ? T_23 extends T_20[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? any : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: any; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_26 ? T_26 extends T_23[K_3] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_4 in keyof T_26]-?: T_26[K_4] extends infer T_27 ? T_27 extends T_26[K_4] ? T_27 extends CanBeExpanded ? T_27["default"] : T_27 : never : never; } : T_26 : never : never; } : T_23 : never : never; } : T_20 : never : never : T_19 extends (infer U)[] ? any[] : T_19 extends object ? { [K_2 in keyof T_19]-?: T_19[K_2] extends infer T_23 ? T_23 extends T_19[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? any : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: any; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_27 ? T_27 extends T_25[K_3] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_28 ? T_28 extends T_27[K_4] ? T_28 extends CanBeExpanded ? T_28["default"] : T_28 : never : never; } : T_27 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_27 ? T_27 extends T_23[K_3] ? T_27 extends CanBeExpanded ? T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_27[PrefixWith, K_3, "."> extends infer T_28 ? T_28 extends PrefixWith, K_3, "."> ? T_28 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_4 in keyof T_27]-?: T_27[K_4] extends infer T_30 ? T_30 extends T_27[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_27 : never : never; } : T_23 : never : never; } : T_19 : never : never : T_18 extends (infer U)[] ? any[] : T_18 extends object ? { [K_2 in keyof T_18]-?: T_18[K_2] extends infer T_23 ? T_23 extends T_18[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? any : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: any; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_28 ? T_28 extends T_26[K_3] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_29 ? T_29 extends T_28[K_4] ? T_29 extends CanBeExpanded ? T_29["default"] : T_29 : never : never; } : T_28 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_28 ? T_28 extends T_25[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_31 ? T_31 extends T_28[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_28 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_28 ? T_28 extends T_23[K_3] ? T_28 extends CanBeExpanded ? T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_28[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith, K_3, "."> extends infer T_29 ? T_29 extends PrefixWith, K_3, "."> ? T_29 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_32 ? T_32 extends T_30[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_30 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_4 in keyof T_28]-?: T_28[K_4] extends infer T_32 ? T_32 extends T_28[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_28 : never : never; } : T_23 : never : never; } : T_18 : never : never : T_17 extends (infer U)[] ? any[] : T_17 extends object ? { [K_2 in keyof T_17]-?: T_17[K_2] extends infer T_23 ? T_23 extends T_17[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? any : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: any; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_29 ? T_29 extends T_27[K_3] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_30 ? T_30 extends T_29[K_4] ? T_30 extends CanBeExpanded ? T_30["default"] : T_30 : never : never; } : T_29 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_29 ? T_29 extends T_26[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_32 ? T_32 extends T_29[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_29 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_29 ? T_29 extends T_25[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_33 ? T_33 extends T_31[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_33 ? T_33 extends T_29[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_29 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_29 ? T_29 extends T_23[K_3] ? T_29 extends CanBeExpanded ? T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_29[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_30 ? T_30 extends PrefixWith, K_3, "."> ? T_30 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_4 in keyof T_29]-?: T_29[K_4] extends infer T_34 ? T_34 extends T_29[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_29 : never : never; } : T_23 : never : never; } : T_17 : never : never : T_16 extends (infer U)[] ? any[] : T_16 extends object ? { [K_2 in keyof T_16]-?: T_16[K_2] extends infer T_23 ? T_23 extends T_16[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? any : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: any; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_30 ? T_30 extends T_28[K_3] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_31 ? T_31 extends T_30[K_4] ? T_31 extends CanBeExpanded ? T_31["default"] : T_31 : never : never; } : T_30 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_30 ? T_30 extends T_27[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_33 ? T_33 extends T_30[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_30 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_30 ? T_30 extends T_26[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_34 ? T_34 extends T_32[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_34 ? T_34 extends T_30[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_30 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_30 ? T_30 extends T_25[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_35 ? T_35 extends T_30[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_30 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_30 ? T_30 extends T_23[K_3] ? T_30 extends CanBeExpanded ? T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_30[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_32[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_31 ? T_31 extends PrefixWith, K_3, "."> ? T_31 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_36 ? T_36 extends T_32[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_4 in keyof T_30]-?: T_30[K_4] extends infer T_36 ? T_36 extends T_30[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_30 : never : never; } : T_23 : never : never; } : T_16 : never : never : T_15 extends (infer U)[] ? any[] : T_15 extends object ? { [K_2 in keyof T_15]-?: T_15[K_2] extends infer T_23 ? T_23 extends T_15[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? any : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_3 in keyof T_30]-?: any; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: T_29[K_3] extends infer T_31 ? T_31 extends T_29[K_3] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_32 ? T_32 extends T_31[K_4] ? T_32 extends CanBeExpanded ? T_32["default"] : T_32 : never : never; } : T_31 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_31 ? T_31 extends T_28[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_34 ? T_34 extends T_31[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_31 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_31 ? T_31 extends T_27[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_35 ? T_35 extends T_33[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_35 ? T_35 extends T_31[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_31 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_31 ? T_31 extends T_26[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_36 ? T_36 extends T_31[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_31 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_31 ? T_31 extends T_25[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_37 ? T_37 extends T_34[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_37 ? T_37 extends T_33[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_37 ? T_37 extends T_31[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_31 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_31 ? T_31 extends T_23[K_3] ? T_31 extends CanBeExpanded ? T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_33 ? T_33 extends T_31[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_33[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_32 ? T_32 extends PrefixWith, K_3, "."> ? T_32 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_38 ? T_38 extends T_37[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_38 ? T_38 extends T_36[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_38 ? T_38 extends T_35[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_38 ? T_38 extends T_34[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_34 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_38 ? T_38 extends T_33[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_33 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_4 in keyof T_31]-?: T_31[K_4] extends infer T_38 ? T_38 extends T_31[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_31 : never : never; } : T_23 : never : never; } : T_15 : never : never : T_14 extends (infer U)[] ? any[] : T_14 extends object ? { [K_2 in keyof T_14]-?: T_14[K_2] extends infer T_23 ? T_23 extends T_14[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? any : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_3 in keyof T_31]-?: any; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_3 in keyof T_30]-?: T_30[K_3] extends infer T_32 ? T_32 extends T_30[K_3] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_33 ? T_33 extends T_32[K_4] ? T_33 extends CanBeExpanded ? T_33["default"] : T_33 : never : never; } : T_32 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: T_29[K_3] extends infer T_32 ? T_32 extends T_29[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? any : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_35 ? T_35 extends T_34[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_35 ? T_35 extends T_32[K_4] ? T_35 extends CanBeExpanded ? T_35["default"] : T_35 : never : never; } : T_32 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_32 ? T_32 extends T_28[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_36 ? T_36 extends T_34[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_36 ? T_36 extends T_32[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_32 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_32 ? T_32 extends T_27[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_37 ? T_37 extends T_34[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_37 ? T_37 extends T_32[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_32 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_32 ? T_32 extends T_26[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_38 ? T_38 extends T_37[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_38 ? T_38 extends T_36[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_38 ? T_38 extends T_35[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_38 ? T_38 extends T_34[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_38 ? T_38 extends T_32[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_32 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_32 ? T_32 extends T_25[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? any : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_39 ? T_39 extends T_38[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_39 ? T_39 extends T_37[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_39 ? T_39 extends T_36[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_39 ? T_39 extends T_35[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_39 ? T_39 extends T_34[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_39 ? T_39 extends T_32[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_32 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_32 ? T_32 extends T_23[K_3] ? T_32 extends CanBeExpanded ? T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_34 ? T_34 extends T_32[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_34 extends CanBeExpanded ? T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_34[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_3, "."> extends infer T_33 ? T_33 extends PrefixWith, K_3, "."> ? T_33 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? any : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_4 in keyof T_39]-?: T_39[K_4] extends infer T_40 ? T_40 extends T_39[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_40 ? T_40 extends T_38[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_40 ? T_40 extends T_37[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_40 ? T_40 extends T_36[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_40 ? T_40 extends T_35[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_35 : never : never : T_34 extends (infer U)[] ? any[] : T_34 extends object ? { [K_4 in keyof T_34]-?: T_34[K_4] extends infer T_40 ? T_40 extends T_34[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_34 : never : never : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_4 in keyof T_32]-?: T_32[K_4] extends infer T_40 ? T_40 extends T_32[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_32 : never : never; } : T_23 : never : never; } : T_14 : never : never : T_12 extends (infer U)[] ? any[] : T_12 extends object ? { [K_2 in keyof T_12]-?: T_12[K_2] extends infer T_23 ? T_23 extends T_12[K_2] ? T_23 extends CanBeExpanded ? T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_25 ? T_25 extends T_23[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_25 extends CanBeExpanded ? T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_26 ? T_26 extends T_25[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_26 extends CanBeExpanded ? T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_27 ? T_27 extends T_26[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_27 extends CanBeExpanded ? T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_28 ? T_28 extends T_27[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_28 extends CanBeExpanded ? T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_29 ? T_29 extends T_28[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_29 extends CanBeExpanded ? T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_30 ? T_30 extends T_29[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_30 extends CanBeExpanded ? T_30[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_31 ? T_31 extends T_30[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_31 extends CanBeExpanded ? T_31[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] extends infer T_32 ? T_32 extends T_31[PrefixWith<`${string & K_1}`, K_2, "."> extends infer T_24 ? T_24 extends PrefixWith<`${string & K_1}`, K_2, "."> ? T_24 extends SplitAC ? "value" : "default" : never : never] ? T_32 extends CanBeExpanded ? any : T_32 extends (infer U)[] ? any[] : T_32 extends object ? { [K_3 in keyof T_32]-?: any; } : T_32 : never : never : T_31 extends (infer U)[] ? any[] : T_31 extends object ? { [K_3 in keyof T_31]-?: T_31[K_3] extends infer T_33 ? T_33 extends T_31[K_3] ? T_33 extends CanBeExpanded ? any : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_34 ? T_34 extends T_33[K_4] ? T_34 extends CanBeExpanded ? T_34["default"] : T_34 : never : never; } : T_33 : never : never; } : T_31 : never : never : T_30 extends (infer U)[] ? any[] : T_30 extends object ? { [K_3 in keyof T_30]-?: T_30[K_3] extends infer T_33 ? T_33 extends T_30[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? any : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_36 ? T_36 extends T_35[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_36 ? T_36 extends T_33[K_4] ? T_36 extends CanBeExpanded ? T_36["default"] : T_36 : never : never; } : T_33 : never : never; } : T_30 : never : never : T_29 extends (infer U)[] ? any[] : T_29 extends object ? { [K_3 in keyof T_29]-?: T_29[K_3] extends infer T_33 ? T_33 extends T_29[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? any : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_37 ? T_37 extends T_36[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_37 ? T_37 extends T_35[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_37 ? T_37 extends T_33[K_4] ? T_37 extends CanBeExpanded ? T_37["default"] : T_37 : never : never; } : T_33 : never : never; } : T_29 : never : never : T_28 extends (infer U)[] ? any[] : T_28 extends object ? { [K_3 in keyof T_28]-?: T_28[K_3] extends infer T_33 ? T_33 extends T_28[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? any : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_38 ? T_38 extends T_37[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_38 ? T_38 extends T_36[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_38 ? T_38 extends T_35[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_38 ? T_38 extends T_33[K_4] ? T_38 extends CanBeExpanded ? T_38["default"] : T_38 : never : never; } : T_33 : never : never; } : T_28 : never : never : T_27 extends (infer U)[] ? any[] : T_27 extends object ? { [K_3 in keyof T_27]-?: T_27[K_3] extends infer T_33 ? T_33 extends T_27[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? any : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_39 ? T_39 extends T_38[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_39 ? T_39 extends T_37[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_39 ? T_39 extends T_36[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_39 ? T_39 extends T_35[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_39 ? T_39 extends T_33[K_4] ? T_39 extends CanBeExpanded ? T_39["default"] : T_39 : never : never; } : T_33 : never : never; } : T_27 : never : never : T_26 extends (infer U)[] ? any[] : T_26 extends object ? { [K_3 in keyof T_26]-?: T_26[K_3] extends infer T_33 ? T_33 extends T_26[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? any : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_4 in keyof T_39]-?: T_39[K_4] extends infer T_40 ? T_40 extends T_39[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_40 ? T_40 extends T_38[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_40 ? T_40 extends T_37[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_40 ? T_40 extends T_36[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_40 ? T_40 extends T_35[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_40 ? T_40 extends T_33[K_4] ? T_40 extends CanBeExpanded ? T_40["default"] : T_40 : never : never; } : T_33 : never : never; } : T_26 : never : never : T_25 extends (infer U)[] ? any[] : T_25 extends object ? { [K_3 in keyof T_25]-?: T_25[K_3] extends infer T_33 ? T_33 extends T_25[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? T_39[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_40 ? T_40 extends T_39[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_40 extends CanBeExpanded ? any : T_40 extends (infer U)[] ? any[] : T_40 extends object ? { [K_4 in keyof T_40]-?: T_40[K_4] extends infer T_41 ? T_41 extends T_40[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_40 : never : never : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_4 in keyof T_39]-?: T_39[K_4] extends infer T_41 ? T_41 extends T_39[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_41 ? T_41 extends T_38[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_41 ? T_41 extends T_37[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_41 ? T_41 extends T_36[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_41 ? T_41 extends T_35[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_41 ? T_41 extends T_33[K_4] ? T_41 extends CanBeExpanded ? T_41["default"] : T_41 : never : never; } : T_33 : never : never; } : T_25 : never : never : T_23 extends (infer U)[] ? any[] : T_23 extends object ? { [K_3 in keyof T_23]-?: T_23[K_3] extends infer T_33 ? T_33 extends T_23[K_3] ? T_33 extends CanBeExpanded ? T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_35 ? T_35 extends T_33[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_35 extends CanBeExpanded ? T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_36 ? T_36 extends T_35[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_36 extends CanBeExpanded ? T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_37 ? T_37 extends T_36[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_37 extends CanBeExpanded ? T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_38 ? T_38 extends T_37[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_38 extends CanBeExpanded ? T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_39 ? T_39 extends T_38[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_39 extends CanBeExpanded ? T_39[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_40 ? T_40 extends T_39[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_40 extends CanBeExpanded ? T_40[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] extends infer T_41 ? T_41 extends T_40[PrefixWith, K_3, "."> extends infer T_34 ? T_34 extends PrefixWith, K_3, "."> ? T_34 extends SplitAC ? "value" : "default" : never : never] ? T_41 extends CanBeExpanded ? any : T_41 extends (infer U)[] ? any[] : T_41 extends object ? { [K_4 in keyof T_41]-?: T_41[K_4] extends infer T_42 ? T_42 extends T_41[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_41 : never : never : T_40 extends (infer U)[] ? any[] : T_40 extends object ? { [K_4 in keyof T_40]-?: T_40[K_4] extends infer T_42 ? T_42 extends T_40[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_40 : never : never : T_39 extends (infer U)[] ? any[] : T_39 extends object ? { [K_4 in keyof T_39]-?: T_39[K_4] extends infer T_42 ? T_42 extends T_39[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_39 : never : never : T_38 extends (infer U)[] ? any[] : T_38 extends object ? { [K_4 in keyof T_38]-?: T_38[K_4] extends infer T_42 ? T_42 extends T_38[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_38 : never : never : T_37 extends (infer U)[] ? any[] : T_37 extends object ? { [K_4 in keyof T_37]-?: T_37[K_4] extends infer T_42 ? T_42 extends T_37[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_37 : never : never : T_36 extends (infer U)[] ? any[] : T_36 extends object ? { [K_4 in keyof T_36]-?: T_36[K_4] extends infer T_42 ? T_42 extends T_36[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_36 : never : never : T_35 extends (infer U)[] ? any[] : T_35 extends object ? { [K_4 in keyof T_35]-?: T_35[K_4] extends infer T_42 ? T_42 extends T_35[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_35 : never : never : T_33 extends (infer U)[] ? any[] : T_33 extends object ? { [K_4 in keyof T_33]-?: T_33[K_4] extends infer T_42 ? T_42 extends T_33[K_4] ? T_42 extends CanBeExpanded ? T_42["default"] : T_42 : never : never; } : T_33 : never : never; } : T_23 : never : never; } : T_12 : never : never; } : T type UseQueryOptions3 = Expand_ extends infer O ? O : never >UseQueryOptions3 : UseQueryOptions3 \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/YieldExpression20_es6.errors.txt b/testdata/baselines/reference/submodule/conformance/YieldExpression20_es6.errors.txt new file mode 100644 index 0000000000..4352abf778 --- /dev/null +++ b/testdata/baselines/reference/submodule/conformance/YieldExpression20_es6.errors.txt @@ -0,0 +1,12 @@ +YieldExpression20_es6.ts(3,8): error TS1163: A 'yield' expression is only allowed in a generator body. + + +==== YieldExpression20_es6.ts (1 errors) ==== + function* test() { + return () => ({ + b: yield 2, // error + ~~~~~ +!!! error TS1163: A 'yield' expression is only allowed in a generator body. + }); + } + \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/YieldExpression20_es6.errors.txt.diff b/testdata/baselines/reference/submodule/conformance/YieldExpression20_es6.errors.txt.diff deleted file mode 100644 index ff9d3f5d74..0000000000 --- a/testdata/baselines/reference/submodule/conformance/YieldExpression20_es6.errors.txt.diff +++ /dev/null @@ -1,16 +0,0 @@ ---- old.YieldExpression20_es6.errors.txt -+++ new.YieldExpression20_es6.errors.txt -@@= skipped -0, +0 lines =@@ --YieldExpression20_es6.ts(3,8): error TS1163: A 'yield' expression is only allowed in a generator body. -- -- --==== YieldExpression20_es6.ts (1 errors) ==== -- function* test() { -- return () => ({ -- b: yield 2, // error -- ~~~~~ --!!! error TS1163: A 'yield' expression is only allowed in a generator body. -- }); -- } -- -+ \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/anonymousClassAccessorsDeclarationEmit1.js b/testdata/baselines/reference/submodule/conformance/anonymousClassAccessorsDeclarationEmit1.js index fbea283f11..97be26cb3b 100644 --- a/testdata/baselines/reference/submodule/conformance/anonymousClassAccessorsDeclarationEmit1.js +++ b/testdata/baselines/reference/submodule/conformance/anonymousClassAccessorsDeclarationEmit1.js @@ -51,14 +51,16 @@ export declare abstract class Base { accessor a: number; } export declare function middle(Super?: typeof Base): abstract new () => { - a: number; + get a(): number; + set a(arg: number); }; declare class A { constructor(...args: any[]); } export declare function Mixin(Super: T): { new (...args: any[]): { - myName: string; + get myName(): string; + set myName(arg: string); }; } & T; export {}; diff --git a/testdata/baselines/reference/submodule/conformance/anonymousClassAccessorsDeclarationEmit1.js.diff b/testdata/baselines/reference/submodule/conformance/anonymousClassAccessorsDeclarationEmit1.js.diff deleted file mode 100644 index 4ea410aa81..0000000000 --- a/testdata/baselines/reference/submodule/conformance/anonymousClassAccessorsDeclarationEmit1.js.diff +++ /dev/null @@ -1,21 +0,0 @@ ---- old.anonymousClassAccessorsDeclarationEmit1.js -+++ new.anonymousClassAccessorsDeclarationEmit1.js -@@= skipped -50, +50 lines =@@ - accessor a: number; - } - export declare function middle(Super?: typeof Base): abstract new () => { -- get a(): number; -- set a(arg: number); -+ a: number; - }; - declare class A { - constructor(...args: any[]); - } - export declare function Mixin(Super: T): { - new (...args: any[]): { -- get myName(): string; -- set myName(arg: string); -+ myName: string; - }; - } & T; - export {}; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/autoAccessor8.js b/testdata/baselines/reference/submodule/conformance/autoAccessor8.js index cb2fb8c393..3203876cec 100644 --- a/testdata/baselines/reference/submodule/conformance/autoAccessor8.js +++ b/testdata/baselines/reference/submodule/conformance/autoAccessor8.js @@ -45,7 +45,9 @@ declare class C2 { } declare function f(): { new (): { - a: any; + get a(): any; + set a(arg: any); }; - b: any; + get b(): any; + set b(arg: any); }; diff --git a/testdata/baselines/reference/submodule/conformance/autoAccessor8.js.diff b/testdata/baselines/reference/submodule/conformance/autoAccessor8.js.diff deleted file mode 100644 index c8d11ac1fc..0000000000 --- a/testdata/baselines/reference/submodule/conformance/autoAccessor8.js.diff +++ /dev/null @@ -1,14 +0,0 @@ ---- old.autoAccessor8.js -+++ new.autoAccessor8.js -@@= skipped -44, +44 lines =@@ - } - declare function f(): { - new (): { -- get a(): any; -- set a(arg: any); -+ a: any; - }; -- get b(): any; -- set b(arg: any); -+ b: any; - }; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/awaitUsingDeclarations.16.errors.txt b/testdata/baselines/reference/submodule/conformance/awaitUsingDeclarations.16.errors.txt index db76601ffa..9cd24341b2 100644 --- a/testdata/baselines/reference/submodule/conformance/awaitUsingDeclarations.16.errors.txt +++ b/testdata/baselines/reference/submodule/conformance/awaitUsingDeclarations.16.errors.txt @@ -1,24 +1,24 @@ -awaitUsingDeclarations.16.ts(2,5): error TS2852: 'await using' statements are only allowed within async functions and at the top levels of modules. -awaitUsingDeclarations.16.ts(3,5): error TS2852: 'await using' statements are only allowed within async functions and at the top levels of modules. -awaitUsingDeclarations.16.ts(6,5): error TS2852: 'await using' statements are only allowed within async functions and at the top levels of modules. -awaitUsingDeclarations.16.ts(7,5): error TS2852: 'await using' statements are only allowed within async functions and at the top levels of modules. +awaitUsingDeclarations.16.ts(2,5): error TS1546: 'await using' declarations are not allowed in ambient contexts. +awaitUsingDeclarations.16.ts(3,5): error TS1546: 'await using' declarations are not allowed in ambient contexts. +awaitUsingDeclarations.16.ts(6,5): error TS1546: 'await using' declarations are not allowed in ambient contexts. +awaitUsingDeclarations.16.ts(7,5): error TS1546: 'await using' declarations are not allowed in ambient contexts. ==== awaitUsingDeclarations.16.ts (4 errors) ==== declare namespace N { await using x: { [Symbol.asyncDispose](): Promise }; - ~~~~~ -!!! error TS2852: 'await using' statements are only allowed within async functions and at the top levels of modules. + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS1546: 'await using' declarations are not allowed in ambient contexts. await using y: null; - ~~~~~ -!!! error TS2852: 'await using' statements are only allowed within async functions and at the top levels of modules. + ~~~~~~~~~~~~~~~~~~~ +!!! error TS1546: 'await using' declarations are not allowed in ambient contexts. } declare module 'M' { await using x: { [Symbol.asyncDispose](): Promise }; - ~~~~~ -!!! error TS2852: 'await using' statements are only allowed within async functions and at the top levels of modules. + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS1546: 'await using' declarations are not allowed in ambient contexts. await using y: null; - ~~~~~ -!!! error TS2852: 'await using' statements are only allowed within async functions and at the top levels of modules. + ~~~~~~~~~~~~~~~~~~~ +!!! error TS1546: 'await using' declarations are not allowed in ambient contexts. } \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/awaitUsingDeclarations.16.errors.txt.diff b/testdata/baselines/reference/submodule/conformance/awaitUsingDeclarations.16.errors.txt.diff deleted file mode 100644 index 08b22b0be7..0000000000 --- a/testdata/baselines/reference/submodule/conformance/awaitUsingDeclarations.16.errors.txt.diff +++ /dev/null @@ -1,39 +0,0 @@ ---- old.awaitUsingDeclarations.16.errors.txt -+++ new.awaitUsingDeclarations.16.errors.txt -@@= skipped -0, +0 lines =@@ --awaitUsingDeclarations.16.ts(2,5): error TS1546: 'await using' declarations are not allowed in ambient contexts. --awaitUsingDeclarations.16.ts(3,5): error TS1546: 'await using' declarations are not allowed in ambient contexts. --awaitUsingDeclarations.16.ts(6,5): error TS1546: 'await using' declarations are not allowed in ambient contexts. --awaitUsingDeclarations.16.ts(7,5): error TS1546: 'await using' declarations are not allowed in ambient contexts. -+awaitUsingDeclarations.16.ts(2,5): error TS2852: 'await using' statements are only allowed within async functions and at the top levels of modules. -+awaitUsingDeclarations.16.ts(3,5): error TS2852: 'await using' statements are only allowed within async functions and at the top levels of modules. -+awaitUsingDeclarations.16.ts(6,5): error TS2852: 'await using' statements are only allowed within async functions and at the top levels of modules. -+awaitUsingDeclarations.16.ts(7,5): error TS2852: 'await using' statements are only allowed within async functions and at the top levels of modules. - - - ==== awaitUsingDeclarations.16.ts (4 errors) ==== - declare namespace N { - await using x: { [Symbol.asyncDispose](): Promise }; -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --!!! error TS1546: 'await using' declarations are not allowed in ambient contexts. -+ ~~~~~ -+!!! error TS2852: 'await using' statements are only allowed within async functions and at the top levels of modules. - await using y: null; -- ~~~~~~~~~~~~~~~~~~~ --!!! error TS1546: 'await using' declarations are not allowed in ambient contexts. -+ ~~~~~ -+!!! error TS2852: 'await using' statements are only allowed within async functions and at the top levels of modules. - } - declare module 'M' { - await using x: { [Symbol.asyncDispose](): Promise }; -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --!!! error TS1546: 'await using' declarations are not allowed in ambient contexts. -+ ~~~~~ -+!!! error TS2852: 'await using' statements are only allowed within async functions and at the top levels of modules. - await using y: null; -- ~~~~~~~~~~~~~~~~~~~ --!!! error TS1546: 'await using' declarations are not allowed in ambient contexts. -+ ~~~~~ -+!!! error TS2852: 'await using' statements are only allowed within async functions and at the top levels of modules. - } - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/classStaticBlock6.errors.txt b/testdata/baselines/reference/submodule/conformance/classStaticBlock6.errors.txt index a576260cf9..7e8a0fa613 100644 --- a/testdata/baselines/reference/submodule/conformance/classStaticBlock6.errors.txt +++ b/testdata/baselines/reference/submodule/conformance/classStaticBlock6.errors.txt @@ -13,9 +13,10 @@ classStaticBlock6.ts(42,18): error TS1109: Expression expected. classStaticBlock6.ts(46,22): error TS1109: Expression expected. classStaticBlock6.ts(55,13): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. classStaticBlock6.ts(66,14): error TS2729: Property 'b' is used before its initialization. +classStaticBlock6.ts(69,18): error TS2729: Property 'b' is used before its initialization. -==== classStaticBlock6.ts (15 errors) ==== +==== classStaticBlock6.ts (16 errors) ==== class B { static a = 1; } @@ -116,6 +117,9 @@ classStaticBlock6.ts(66,14): error TS2729: Property 'b' is used before its initi let b: typeof this.b; // ok if (1) { this.b; // should error + ~ +!!! error TS2729: Property 'b' is used before its initialization. +!!! related TS2728 classStaticBlock6.ts:73:12: 'b' is declared here. } } diff --git a/testdata/baselines/reference/submodule/conformance/classStaticBlock6.errors.txt.diff b/testdata/baselines/reference/submodule/conformance/classStaticBlock6.errors.txt.diff index c3738627fd..5e113bc0ec 100644 --- a/testdata/baselines/reference/submodule/conformance/classStaticBlock6.errors.txt.diff +++ b/testdata/baselines/reference/submodule/conformance/classStaticBlock6.errors.txt.diff @@ -8,17 +8,15 @@ classStaticBlock6.ts(46,22): error TS1109: Expression expected. classStaticBlock6.ts(55,13): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks. classStaticBlock6.ts(66,14): error TS2729: Property 'b' is used before its initialization. --classStaticBlock6.ts(69,18): error TS2729: Property 'b' is used before its initialization. -- -- + classStaticBlock6.ts(69,18): error TS2729: Property 'b' is used before its initialization. + + -==== classStaticBlock6.ts (17 errors) ==== -+ -+ -+==== classStaticBlock6.ts (15 errors) ==== ++==== classStaticBlock6.ts (16 errors) ==== class B { static a = 1; } -@@= skipped -77, +75 lines =@@ +@@= skipped -77, +76 lines =@@ async function ff () { arguments; @@ -26,14 +24,4 @@ -!!! error TS2522: The 'arguments' object cannot be referenced in an async function or method in ES5. Consider using a standard function or method. await; ~ - !!! error TS1109: Expression expected. -@@= skipped -33, +31 lines =@@ - let b: typeof this.b; // ok - if (1) { - this.b; // should error -- ~ --!!! error TS2729: Property 'b' is used before its initialization. --!!! related TS2728 classStaticBlock6.ts:73:12: 'b' is declared here. - } - } - \ No newline at end of file + !!! error TS1109: Expression expected. \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/dependentDestructuredVariablesWithExport.types b/testdata/baselines/reference/submodule/conformance/dependentDestructuredVariablesWithExport.types index b1c5ddb783..e52d955c98 100644 --- a/testdata/baselines/reference/submodule/conformance/dependentDestructuredVariablesWithExport.types +++ b/testdata/baselines/reference/submodule/conformance/dependentDestructuredVariablesWithExport.types @@ -49,5 +49,5 @@ if (discriminator2) { >discriminator2 : boolean value2; ->value2 : string | null | undefined +>value2 : string } diff --git a/testdata/baselines/reference/submodule/conformance/dependentDestructuredVariablesWithExport.types.diff b/testdata/baselines/reference/submodule/conformance/dependentDestructuredVariablesWithExport.types.diff deleted file mode 100644 index aad1a04386..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dependentDestructuredVariablesWithExport.types.diff +++ /dev/null @@ -1,9 +0,0 @@ ---- old.dependentDestructuredVariablesWithExport.types -+++ new.dependentDestructuredVariablesWithExport.types -@@= skipped -48, +48 lines =@@ - >discriminator2 : boolean - - value2; -->value2 : string -+>value2 : string | null | undefined - } \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).errors.txt b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).errors.txt index 047f031b14..bdf61f9266 100644 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).errors.txt +++ b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).errors.txt @@ -1,5 +1,4 @@ -b.ts(1,1): error TS1343: The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'es2022', 'esnext', 'system', 'node16', 'node18', 'node20', or 'nodenext'. -b.ts(1,8): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? +b.ts(1,1): error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. ==== a.ts (0 errors) ==== @@ -7,12 +6,10 @@ b.ts(1,8): error TS17012: 'defer' is not a valid meta-property for keyword 'impo console.log("foo from a"); } -==== b.ts (2 errors) ==== +==== b.ts (1 errors) ==== import.defer("./a.js").then(ns => { - ~~~~~~~~~~~~ -!!! error TS1343: The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'es2022', 'esnext', 'system', 'node16', 'node18', 'node20', or 'nodenext'. - ~~~~~ -!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? + ~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. ns.foo(); }); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).errors.txt.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).errors.txt.diff deleted file mode 100644 index f3fc19f962..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).errors.txt.diff +++ /dev/null @@ -1,25 +0,0 @@ ---- old.dynamicImportDefer(module=commonjs).errors.txt -+++ new.dynamicImportDefer(module=commonjs).errors.txt -@@= skipped -0, +0 lines =@@ --b.ts(1,1): error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. -+b.ts(1,1): error TS1343: The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'es2022', 'esnext', 'system', 'node16', 'node18', 'node20', or 'nodenext'. -+b.ts(1,8): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - - - ==== a.ts (0 errors) ==== -@@= skipped -5, +6 lines =@@ - console.log("foo from a"); - } - --==== b.ts (1 errors) ==== -+==== b.ts (2 errors) ==== - import.defer("./a.js").then(ns => { -- ~~~~~~~~~~~~~~~~~~~~~~ --!!! error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. -+ ~~~~~~~~~~~~ -+!!! error TS1343: The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'es2022', 'esnext', 'system', 'node16', 'node18', 'node20', or 'nodenext'. -+ ~~~~~ -+!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - ns.foo(); - }); - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).symbols b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).symbols index d743f863f2..291ceeb4fb 100644 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).symbols +++ b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).symbols @@ -12,10 +12,15 @@ export function foo() { === b.ts === import.defer("./a.js").then(ns => { +>import.defer("./a.js").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) +>"./a.js" : Symbol("a", Decl(a.ts, 0, 0)) +>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) >ns : Symbol(ns, Decl(b.ts, 0, 28)) ns.foo(); +>ns.foo : Symbol(foo, Decl(a.ts, 0, 0)) >ns : Symbol(ns, Decl(b.ts, 0, 28)) +>foo : Symbol(foo, Decl(a.ts, 0, 0)) }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).symbols.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).symbols.diff deleted file mode 100644 index bb6a38359c..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).symbols.diff +++ /dev/null @@ -1,17 +0,0 @@ ---- old.dynamicImportDefer(module=commonjs).symbols -+++ new.dynamicImportDefer(module=commonjs).symbols -@@= skipped -11, +11 lines =@@ - - === b.ts === - import.defer("./a.js").then(ns => { -->import.defer("./a.js").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) -->"./a.js" : Symbol("a", Decl(a.ts, 0, 0)) -->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) - >ns : Symbol(ns, Decl(b.ts, 0, 28)) - - ns.foo(); -->ns.foo : Symbol(foo, Decl(a.ts, 0, 0)) - >ns : Symbol(ns, Decl(b.ts, 0, 28)) -->foo : Symbol(foo, Decl(a.ts, 0, 0)) - - }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).types b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).types index 5c941e8ec2..d1ab662fb2 100644 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).types +++ b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).types @@ -14,21 +14,20 @@ export function foo() { === b.ts === import.defer("./a.js").then(ns => { ->import.defer("./a.js").then(ns => { ns.foo();}) : any ->import.defer("./a.js").then : any ->import.defer("./a.js") : any ->import.defer : any +>import.defer("./a.js").then(ns => { ns.foo();}) : Promise +>import.defer("./a.js").then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +>import.defer("./a.js") : Promise >defer : any >"./a.js" : "./a.js" ->then : any ->ns => { ns.foo();} : (ns: any) => void ->ns : any +>then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +>ns => { ns.foo();} : (ns: typeof import("a")) => void +>ns : typeof import("a") ns.foo(); ->ns.foo() : any ->ns.foo : any ->ns : any ->foo : any +>ns.foo() : void +>ns.foo : () => void +>ns : typeof import("a") +>foo : () => void }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).types.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).types.diff deleted file mode 100644 index 6a9581c019..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=commonjs).types.diff +++ /dev/null @@ -1,33 +0,0 @@ ---- old.dynamicImportDefer(module=commonjs).types -+++ new.dynamicImportDefer(module=commonjs).types -@@= skipped -13, +13 lines =@@ - - === b.ts === - import.defer("./a.js").then(ns => { -->import.defer("./a.js").then(ns => { ns.foo();}) : Promise -->import.defer("./a.js").then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -->import.defer("./a.js") : Promise -+>import.defer("./a.js").then(ns => { ns.foo();}) : any -+>import.defer("./a.js").then : any -+>import.defer("./a.js") : any -+>import.defer : any - >defer : any - >"./a.js" : "./a.js" -->then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -->ns => { ns.foo();} : (ns: typeof import("a")) => void -->ns : typeof import("a") -+>then : any -+>ns => { ns.foo();} : (ns: any) => void -+>ns : any - - ns.foo(); -->ns.foo() : void -->ns.foo : () => void -->ns : typeof import("a") -->foo : () => void -+>ns.foo() : any -+>ns.foo : any -+>ns : any -+>foo : any - - }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).errors.txt b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).errors.txt index 047f031b14..bdf61f9266 100644 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).errors.txt +++ b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).errors.txt @@ -1,5 +1,4 @@ -b.ts(1,1): error TS1343: The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'es2022', 'esnext', 'system', 'node16', 'node18', 'node20', or 'nodenext'. -b.ts(1,8): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? +b.ts(1,1): error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. ==== a.ts (0 errors) ==== @@ -7,12 +6,10 @@ b.ts(1,8): error TS17012: 'defer' is not a valid meta-property for keyword 'impo console.log("foo from a"); } -==== b.ts (2 errors) ==== +==== b.ts (1 errors) ==== import.defer("./a.js").then(ns => { - ~~~~~~~~~~~~ -!!! error TS1343: The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'es2022', 'esnext', 'system', 'node16', 'node18', 'node20', or 'nodenext'. - ~~~~~ -!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? + ~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. ns.foo(); }); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).errors.txt.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).errors.txt.diff deleted file mode 100644 index 24d6ae79bb..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).errors.txt.diff +++ /dev/null @@ -1,25 +0,0 @@ ---- old.dynamicImportDefer(module=es2015).errors.txt -+++ new.dynamicImportDefer(module=es2015).errors.txt -@@= skipped -0, +0 lines =@@ --b.ts(1,1): error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. -+b.ts(1,1): error TS1343: The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'es2022', 'esnext', 'system', 'node16', 'node18', 'node20', or 'nodenext'. -+b.ts(1,8): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - - - ==== a.ts (0 errors) ==== -@@= skipped -5, +6 lines =@@ - console.log("foo from a"); - } - --==== b.ts (1 errors) ==== -+==== b.ts (2 errors) ==== - import.defer("./a.js").then(ns => { -- ~~~~~~~~~~~~~~~~~~~~~~ --!!! error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. -+ ~~~~~~~~~~~~ -+!!! error TS1343: The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'es2022', 'esnext', 'system', 'node16', 'node18', 'node20', or 'nodenext'. -+ ~~~~~ -+!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - ns.foo(); - }); - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).symbols b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).symbols index d743f863f2..291ceeb4fb 100644 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).symbols +++ b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).symbols @@ -12,10 +12,15 @@ export function foo() { === b.ts === import.defer("./a.js").then(ns => { +>import.defer("./a.js").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) +>"./a.js" : Symbol("a", Decl(a.ts, 0, 0)) +>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) >ns : Symbol(ns, Decl(b.ts, 0, 28)) ns.foo(); +>ns.foo : Symbol(foo, Decl(a.ts, 0, 0)) >ns : Symbol(ns, Decl(b.ts, 0, 28)) +>foo : Symbol(foo, Decl(a.ts, 0, 0)) }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).symbols.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).symbols.diff deleted file mode 100644 index a3e29c41fb..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).symbols.diff +++ /dev/null @@ -1,17 +0,0 @@ ---- old.dynamicImportDefer(module=es2015).symbols -+++ new.dynamicImportDefer(module=es2015).symbols -@@= skipped -11, +11 lines =@@ - - === b.ts === - import.defer("./a.js").then(ns => { -->import.defer("./a.js").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) -->"./a.js" : Symbol("a", Decl(a.ts, 0, 0)) -->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) - >ns : Symbol(ns, Decl(b.ts, 0, 28)) - - ns.foo(); -->ns.foo : Symbol(foo, Decl(a.ts, 0, 0)) - >ns : Symbol(ns, Decl(b.ts, 0, 28)) -->foo : Symbol(foo, Decl(a.ts, 0, 0)) - - }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).types b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).types index 5c941e8ec2..d1ab662fb2 100644 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).types +++ b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).types @@ -14,21 +14,20 @@ export function foo() { === b.ts === import.defer("./a.js").then(ns => { ->import.defer("./a.js").then(ns => { ns.foo();}) : any ->import.defer("./a.js").then : any ->import.defer("./a.js") : any ->import.defer : any +>import.defer("./a.js").then(ns => { ns.foo();}) : Promise +>import.defer("./a.js").then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +>import.defer("./a.js") : Promise >defer : any >"./a.js" : "./a.js" ->then : any ->ns => { ns.foo();} : (ns: any) => void ->ns : any +>then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +>ns => { ns.foo();} : (ns: typeof import("a")) => void +>ns : typeof import("a") ns.foo(); ->ns.foo() : any ->ns.foo : any ->ns : any ->foo : any +>ns.foo() : void +>ns.foo : () => void +>ns : typeof import("a") +>foo : () => void }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).types.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).types.diff deleted file mode 100644 index 7e6f62019b..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2015).types.diff +++ /dev/null @@ -1,33 +0,0 @@ ---- old.dynamicImportDefer(module=es2015).types -+++ new.dynamicImportDefer(module=es2015).types -@@= skipped -13, +13 lines =@@ - - === b.ts === - import.defer("./a.js").then(ns => { -->import.defer("./a.js").then(ns => { ns.foo();}) : Promise -->import.defer("./a.js").then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -->import.defer("./a.js") : Promise -+>import.defer("./a.js").then(ns => { ns.foo();}) : any -+>import.defer("./a.js").then : any -+>import.defer("./a.js") : any -+>import.defer : any - >defer : any - >"./a.js" : "./a.js" -->then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -->ns => { ns.foo();} : (ns: typeof import("a")) => void -->ns : typeof import("a") -+>then : any -+>ns => { ns.foo();} : (ns: any) => void -+>ns : any - - ns.foo(); -->ns.foo() : void -->ns.foo : () => void -->ns : typeof import("a") -->foo : () => void -+>ns.foo() : any -+>ns.foo : any -+>ns : any -+>foo : any - - }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).errors.txt b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).errors.txt index 41ce75c7e9..bdf61f9266 100644 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).errors.txt +++ b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).errors.txt @@ -1,4 +1,4 @@ -b.ts(1,8): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? +b.ts(1,1): error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. ==== a.ts (0 errors) ==== @@ -8,8 +8,8 @@ b.ts(1,8): error TS17012: 'defer' is not a valid meta-property for keyword 'impo ==== b.ts (1 errors) ==== import.defer("./a.js").then(ns => { - ~~~~~ -!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? + ~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. ns.foo(); }); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).errors.txt.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).errors.txt.diff deleted file mode 100644 index 5911513c5d..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).errors.txt.diff +++ /dev/null @@ -1,19 +0,0 @@ ---- old.dynamicImportDefer(module=es2020).errors.txt -+++ new.dynamicImportDefer(module=es2020).errors.txt -@@= skipped -0, +0 lines =@@ --b.ts(1,1): error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. -+b.ts(1,8): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - - - ==== a.ts (0 errors) ==== -@@= skipped -7, +7 lines =@@ - - ==== b.ts (1 errors) ==== - import.defer("./a.js").then(ns => { -- ~~~~~~~~~~~~~~~~~~~~~~ --!!! error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. -+ ~~~~~ -+!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - ns.foo(); - }); - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).symbols b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).symbols index d743f863f2..291ceeb4fb 100644 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).symbols +++ b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).symbols @@ -12,10 +12,15 @@ export function foo() { === b.ts === import.defer("./a.js").then(ns => { +>import.defer("./a.js").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) +>"./a.js" : Symbol("a", Decl(a.ts, 0, 0)) +>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) >ns : Symbol(ns, Decl(b.ts, 0, 28)) ns.foo(); +>ns.foo : Symbol(foo, Decl(a.ts, 0, 0)) >ns : Symbol(ns, Decl(b.ts, 0, 28)) +>foo : Symbol(foo, Decl(a.ts, 0, 0)) }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).symbols.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).symbols.diff deleted file mode 100644 index 2d2914a2bc..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).symbols.diff +++ /dev/null @@ -1,17 +0,0 @@ ---- old.dynamicImportDefer(module=es2020).symbols -+++ new.dynamicImportDefer(module=es2020).symbols -@@= skipped -11, +11 lines =@@ - - === b.ts === - import.defer("./a.js").then(ns => { -->import.defer("./a.js").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) -->"./a.js" : Symbol("a", Decl(a.ts, 0, 0)) -->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) - >ns : Symbol(ns, Decl(b.ts, 0, 28)) - - ns.foo(); -->ns.foo : Symbol(foo, Decl(a.ts, 0, 0)) - >ns : Symbol(ns, Decl(b.ts, 0, 28)) -->foo : Symbol(foo, Decl(a.ts, 0, 0)) - - }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).types b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).types index 5c941e8ec2..d1ab662fb2 100644 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).types +++ b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).types @@ -14,21 +14,20 @@ export function foo() { === b.ts === import.defer("./a.js").then(ns => { ->import.defer("./a.js").then(ns => { ns.foo();}) : any ->import.defer("./a.js").then : any ->import.defer("./a.js") : any ->import.defer : any +>import.defer("./a.js").then(ns => { ns.foo();}) : Promise +>import.defer("./a.js").then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +>import.defer("./a.js") : Promise >defer : any >"./a.js" : "./a.js" ->then : any ->ns => { ns.foo();} : (ns: any) => void ->ns : any +>then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +>ns => { ns.foo();} : (ns: typeof import("a")) => void +>ns : typeof import("a") ns.foo(); ->ns.foo() : any ->ns.foo : any ->ns : any ->foo : any +>ns.foo() : void +>ns.foo : () => void +>ns : typeof import("a") +>foo : () => void }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).types.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).types.diff deleted file mode 100644 index c580a9654b..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=es2020).types.diff +++ /dev/null @@ -1,33 +0,0 @@ ---- old.dynamicImportDefer(module=es2020).types -+++ new.dynamicImportDefer(module=es2020).types -@@= skipped -13, +13 lines =@@ - - === b.ts === - import.defer("./a.js").then(ns => { -->import.defer("./a.js").then(ns => { ns.foo();}) : Promise -->import.defer("./a.js").then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -->import.defer("./a.js") : Promise -+>import.defer("./a.js").then(ns => { ns.foo();}) : any -+>import.defer("./a.js").then : any -+>import.defer("./a.js") : any -+>import.defer : any - >defer : any - >"./a.js" : "./a.js" -->then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -->ns => { ns.foo();} : (ns: typeof import("a")) => void -->ns : typeof import("a") -+>then : any -+>ns => { ns.foo();} : (ns: any) => void -+>ns : any - - ns.foo(); -->ns.foo() : void -->ns.foo : () => void -->ns : typeof import("a") -->foo : () => void -+>ns.foo() : any -+>ns.foo : any -+>ns : any -+>foo : any - - }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).errors.txt b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).errors.txt deleted file mode 100644 index 41ce75c7e9..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).errors.txt +++ /dev/null @@ -1,15 +0,0 @@ -b.ts(1,8): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - - -==== a.ts (0 errors) ==== - export function foo() { - console.log("foo from a"); - } - -==== b.ts (1 errors) ==== - import.defer("./a.js").then(ns => { - ~~~~~ -!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - ns.foo(); - }); - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).errors.txt.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).errors.txt.diff deleted file mode 100644 index 08f576580b..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).errors.txt.diff +++ /dev/null @@ -1,19 +0,0 @@ ---- old.dynamicImportDefer(module=esnext).errors.txt -+++ new.dynamicImportDefer(module=esnext).errors.txt -@@= skipped -0, +0 lines =@@ -- -+b.ts(1,8): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? -+ -+ -+==== a.ts (0 errors) ==== -+ export function foo() { -+ console.log("foo from a"); -+ } -+ -+==== b.ts (1 errors) ==== -+ import.defer("./a.js").then(ns => { -+ ~~~~~ -+!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? -+ ns.foo(); -+ }); -+ \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).symbols b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).symbols index d743f863f2..291ceeb4fb 100644 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).symbols +++ b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).symbols @@ -12,10 +12,15 @@ export function foo() { === b.ts === import.defer("./a.js").then(ns => { +>import.defer("./a.js").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) +>"./a.js" : Symbol("a", Decl(a.ts, 0, 0)) +>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) >ns : Symbol(ns, Decl(b.ts, 0, 28)) ns.foo(); +>ns.foo : Symbol(foo, Decl(a.ts, 0, 0)) >ns : Symbol(ns, Decl(b.ts, 0, 28)) +>foo : Symbol(foo, Decl(a.ts, 0, 0)) }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).symbols.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).symbols.diff deleted file mode 100644 index 0ab0a2ea2c..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).symbols.diff +++ /dev/null @@ -1,17 +0,0 @@ ---- old.dynamicImportDefer(module=esnext).symbols -+++ new.dynamicImportDefer(module=esnext).symbols -@@= skipped -11, +11 lines =@@ - - === b.ts === - import.defer("./a.js").then(ns => { -->import.defer("./a.js").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) -->"./a.js" : Symbol("a", Decl(a.ts, 0, 0)) -->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) - >ns : Symbol(ns, Decl(b.ts, 0, 28)) - - ns.foo(); -->ns.foo : Symbol(foo, Decl(a.ts, 0, 0)) - >ns : Symbol(ns, Decl(b.ts, 0, 28)) -->foo : Symbol(foo, Decl(a.ts, 0, 0)) - - }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).types b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).types index 5c941e8ec2..d1ab662fb2 100644 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).types +++ b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).types @@ -14,21 +14,20 @@ export function foo() { === b.ts === import.defer("./a.js").then(ns => { ->import.defer("./a.js").then(ns => { ns.foo();}) : any ->import.defer("./a.js").then : any ->import.defer("./a.js") : any ->import.defer : any +>import.defer("./a.js").then(ns => { ns.foo();}) : Promise +>import.defer("./a.js").then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +>import.defer("./a.js") : Promise >defer : any >"./a.js" : "./a.js" ->then : any ->ns => { ns.foo();} : (ns: any) => void ->ns : any +>then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +>ns => { ns.foo();} : (ns: typeof import("a")) => void +>ns : typeof import("a") ns.foo(); ->ns.foo() : any ->ns.foo : any ->ns : any ->foo : any +>ns.foo() : void +>ns.foo : () => void +>ns : typeof import("a") +>foo : () => void }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).types.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).types.diff deleted file mode 100644 index b298869fa2..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=esnext).types.diff +++ /dev/null @@ -1,33 +0,0 @@ ---- old.dynamicImportDefer(module=esnext).types -+++ new.dynamicImportDefer(module=esnext).types -@@= skipped -13, +13 lines =@@ - - === b.ts === - import.defer("./a.js").then(ns => { -->import.defer("./a.js").then(ns => { ns.foo();}) : Promise -->import.defer("./a.js").then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -->import.defer("./a.js") : Promise -+>import.defer("./a.js").then(ns => { ns.foo();}) : any -+>import.defer("./a.js").then : any -+>import.defer("./a.js") : any -+>import.defer : any - >defer : any - >"./a.js" : "./a.js" -->then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -->ns => { ns.foo();} : (ns: typeof import("a")) => void -->ns : typeof import("a") -+>then : any -+>ns => { ns.foo();} : (ns: any) => void -+>ns : any - - ns.foo(); -->ns.foo() : void -->ns.foo : () => void -->ns : typeof import("a") -->foo : () => void -+>ns.foo() : any -+>ns.foo : any -+>ns : any -+>foo : any - - }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).errors.txt b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).errors.txt index 5e61810e78..bdf61f9266 100644 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).errors.txt +++ b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).errors.txt @@ -1,5 +1,4 @@ -b.ts(1,1): error TS1470: The 'import.meta' meta-property is not allowed in files which will build into CommonJS output. -b.ts(1,8): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? +b.ts(1,1): error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. ==== a.ts (0 errors) ==== @@ -7,12 +6,10 @@ b.ts(1,8): error TS17012: 'defer' is not a valid meta-property for keyword 'impo console.log("foo from a"); } -==== b.ts (2 errors) ==== +==== b.ts (1 errors) ==== import.defer("./a.js").then(ns => { - ~~~~~~~~~~~~ -!!! error TS1470: The 'import.meta' meta-property is not allowed in files which will build into CommonJS output. - ~~~~~ -!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? + ~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. ns.foo(); }); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).errors.txt.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).errors.txt.diff deleted file mode 100644 index 2bb7e40d7d..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).errors.txt.diff +++ /dev/null @@ -1,25 +0,0 @@ ---- old.dynamicImportDefer(module=nodenext).errors.txt -+++ new.dynamicImportDefer(module=nodenext).errors.txt -@@= skipped -0, +0 lines =@@ --b.ts(1,1): error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. -+b.ts(1,1): error TS1470: The 'import.meta' meta-property is not allowed in files which will build into CommonJS output. -+b.ts(1,8): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - - - ==== a.ts (0 errors) ==== -@@= skipped -5, +6 lines =@@ - console.log("foo from a"); - } - --==== b.ts (1 errors) ==== -+==== b.ts (2 errors) ==== - import.defer("./a.js").then(ns => { -- ~~~~~~~~~~~~~~~~~~~~~~ --!!! error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. -+ ~~~~~~~~~~~~ -+!!! error TS1470: The 'import.meta' meta-property is not allowed in files which will build into CommonJS output. -+ ~~~~~ -+!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - ns.foo(); - }); - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).symbols b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).symbols index d743f863f2..291ceeb4fb 100644 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).symbols +++ b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).symbols @@ -12,10 +12,15 @@ export function foo() { === b.ts === import.defer("./a.js").then(ns => { +>import.defer("./a.js").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) +>"./a.js" : Symbol("a", Decl(a.ts, 0, 0)) +>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) >ns : Symbol(ns, Decl(b.ts, 0, 28)) ns.foo(); +>ns.foo : Symbol(foo, Decl(a.ts, 0, 0)) >ns : Symbol(ns, Decl(b.ts, 0, 28)) +>foo : Symbol(foo, Decl(a.ts, 0, 0)) }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).symbols.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).symbols.diff deleted file mode 100644 index bd20c32b6c..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).symbols.diff +++ /dev/null @@ -1,17 +0,0 @@ ---- old.dynamicImportDefer(module=nodenext).symbols -+++ new.dynamicImportDefer(module=nodenext).symbols -@@= skipped -11, +11 lines =@@ - - === b.ts === - import.defer("./a.js").then(ns => { -->import.defer("./a.js").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) -->"./a.js" : Symbol("a", Decl(a.ts, 0, 0)) -->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) - >ns : Symbol(ns, Decl(b.ts, 0, 28)) - - ns.foo(); -->ns.foo : Symbol(foo, Decl(a.ts, 0, 0)) - >ns : Symbol(ns, Decl(b.ts, 0, 28)) -->foo : Symbol(foo, Decl(a.ts, 0, 0)) - - }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).types b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).types index 5c941e8ec2..977b76f603 100644 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).types +++ b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).types @@ -14,21 +14,20 @@ export function foo() { === b.ts === import.defer("./a.js").then(ns => { ->import.defer("./a.js").then(ns => { ns.foo();}) : any ->import.defer("./a.js").then : any ->import.defer("./a.js") : any ->import.defer : any +>import.defer("./a.js").then(ns => { ns.foo();}) : Promise +>import.defer("./a.js").then : (onfulfilled?: (value: { foo(): void; default: typeof import("a"); }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +>import.defer("./a.js") : Promise<{ foo(): void; default: typeof import("a"); }> >defer : any >"./a.js" : "./a.js" ->then : any ->ns => { ns.foo();} : (ns: any) => void ->ns : any +>then : (onfulfilled?: (value: { foo(): void; default: typeof import("a"); }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +>ns => { ns.foo();} : (ns: { foo(): void; default: typeof import("a"); }) => void +>ns : { foo(): void; default: typeof import("a"); } ns.foo(); ->ns.foo() : any ->ns.foo : any ->ns : any ->foo : any +>ns.foo() : void +>ns.foo : () => void +>ns : { foo(): void; default: typeof import("a"); } +>foo : () => void }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).types.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).types.diff deleted file mode 100644 index 0bd2ede9a5..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=nodenext).types.diff +++ /dev/null @@ -1,33 +0,0 @@ ---- old.dynamicImportDefer(module=nodenext).types -+++ new.dynamicImportDefer(module=nodenext).types -@@= skipped -13, +13 lines =@@ - - === b.ts === - import.defer("./a.js").then(ns => { -->import.defer("./a.js").then(ns => { ns.foo();}) : Promise -->import.defer("./a.js").then : (onfulfilled?: (value: { foo(): void; default: typeof import("a"); }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -->import.defer("./a.js") : Promise<{ foo(): void; default: typeof import("a"); }> -+>import.defer("./a.js").then(ns => { ns.foo();}) : any -+>import.defer("./a.js").then : any -+>import.defer("./a.js") : any -+>import.defer : any - >defer : any - >"./a.js" : "./a.js" -->then : (onfulfilled?: (value: { foo(): void; default: typeof import("a"); }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -->ns => { ns.foo();} : (ns: { foo(): void; default: typeof import("a"); }) => void -->ns : { foo(): void; default: typeof import("a"); } -+>then : any -+>ns => { ns.foo();} : (ns: any) => void -+>ns : any - - ns.foo(); -->ns.foo() : void -->ns.foo : () => void -->ns : { foo(): void; default: typeof import("a"); } -->foo : () => void -+>ns.foo() : any -+>ns.foo : any -+>ns : any -+>foo : any - - }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).errors.txt b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).errors.txt deleted file mode 100644 index 41ce75c7e9..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).errors.txt +++ /dev/null @@ -1,15 +0,0 @@ -b.ts(1,8): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - - -==== a.ts (0 errors) ==== - export function foo() { - console.log("foo from a"); - } - -==== b.ts (1 errors) ==== - import.defer("./a.js").then(ns => { - ~~~~~ -!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - ns.foo(); - }); - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).errors.txt.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).errors.txt.diff deleted file mode 100644 index c4884f20f1..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).errors.txt.diff +++ /dev/null @@ -1,19 +0,0 @@ ---- old.dynamicImportDefer(module=preserve).errors.txt -+++ new.dynamicImportDefer(module=preserve).errors.txt -@@= skipped -0, +0 lines =@@ -- -+b.ts(1,8): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? -+ -+ -+==== a.ts (0 errors) ==== -+ export function foo() { -+ console.log("foo from a"); -+ } -+ -+==== b.ts (1 errors) ==== -+ import.defer("./a.js").then(ns => { -+ ~~~~~ -+!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? -+ ns.foo(); -+ }); -+ \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).symbols b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).symbols index d743f863f2..291ceeb4fb 100644 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).symbols +++ b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).symbols @@ -12,10 +12,15 @@ export function foo() { === b.ts === import.defer("./a.js").then(ns => { +>import.defer("./a.js").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) +>"./a.js" : Symbol("a", Decl(a.ts, 0, 0)) +>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) >ns : Symbol(ns, Decl(b.ts, 0, 28)) ns.foo(); +>ns.foo : Symbol(foo, Decl(a.ts, 0, 0)) >ns : Symbol(ns, Decl(b.ts, 0, 28)) +>foo : Symbol(foo, Decl(a.ts, 0, 0)) }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).symbols.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).symbols.diff deleted file mode 100644 index b83e079ff0..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).symbols.diff +++ /dev/null @@ -1,17 +0,0 @@ ---- old.dynamicImportDefer(module=preserve).symbols -+++ new.dynamicImportDefer(module=preserve).symbols -@@= skipped -11, +11 lines =@@ - - === b.ts === - import.defer("./a.js").then(ns => { -->import.defer("./a.js").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) -->"./a.js" : Symbol("a", Decl(a.ts, 0, 0)) -->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) - >ns : Symbol(ns, Decl(b.ts, 0, 28)) - - ns.foo(); -->ns.foo : Symbol(foo, Decl(a.ts, 0, 0)) - >ns : Symbol(ns, Decl(b.ts, 0, 28)) -->foo : Symbol(foo, Decl(a.ts, 0, 0)) - - }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).types b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).types index 5c941e8ec2..d1ab662fb2 100644 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).types +++ b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).types @@ -14,21 +14,20 @@ export function foo() { === b.ts === import.defer("./a.js").then(ns => { ->import.defer("./a.js").then(ns => { ns.foo();}) : any ->import.defer("./a.js").then : any ->import.defer("./a.js") : any ->import.defer : any +>import.defer("./a.js").then(ns => { ns.foo();}) : Promise +>import.defer("./a.js").then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +>import.defer("./a.js") : Promise >defer : any >"./a.js" : "./a.js" ->then : any ->ns => { ns.foo();} : (ns: any) => void ->ns : any +>then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +>ns => { ns.foo();} : (ns: typeof import("a")) => void +>ns : typeof import("a") ns.foo(); ->ns.foo() : any ->ns.foo : any ->ns : any ->foo : any +>ns.foo() : void +>ns.foo : () => void +>ns : typeof import("a") +>foo : () => void }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).types.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).types.diff deleted file mode 100644 index aca1c77160..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDefer(module=preserve).types.diff +++ /dev/null @@ -1,33 +0,0 @@ ---- old.dynamicImportDefer(module=preserve).types -+++ new.dynamicImportDefer(module=preserve).types -@@= skipped -13, +13 lines =@@ - - === b.ts === - import.defer("./a.js").then(ns => { -->import.defer("./a.js").then(ns => { ns.foo();}) : Promise -->import.defer("./a.js").then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -->import.defer("./a.js") : Promise -+>import.defer("./a.js").then(ns => { ns.foo();}) : any -+>import.defer("./a.js").then : any -+>import.defer("./a.js") : any -+>import.defer : any - >defer : any - >"./a.js" : "./a.js" -->then : (onfulfilled?: (value: typeof import("a")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -->ns => { ns.foo();} : (ns: typeof import("a")) => void -->ns : typeof import("a") -+>then : any -+>ns => { ns.foo();} : (ns: any) => void -+>ns : any - - ns.foo(); -->ns.foo() : void -->ns.foo : () => void -->ns : typeof import("a") -->foo : () => void -+>ns.foo() : any -+>ns.foo : any -+>ns : any -+>foo : any - - }); diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDeferInvalidStandalone.errors.txt b/testdata/baselines/reference/submodule/conformance/dynamicImportDeferInvalidStandalone.errors.txt index 444384fb22..fb28ea715a 100644 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDeferInvalidStandalone.errors.txt +++ b/testdata/baselines/reference/submodule/conformance/dynamicImportDeferInvalidStandalone.errors.txt @@ -1,22 +1,22 @@ -b.ts(1,8): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? -b.ts(3,9): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? -b.ts(5,17): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? -b.ts(7,8): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? +b.ts(1,13): error TS1005: '(' expected. +b.ts(3,14): error TS1005: '(' expected. +b.ts(5,22): error TS1005: '(' expected. +b.ts(7,13): error TS1005: '(' expected. ==== b.ts (4 errors) ==== import.defer; - ~~~~~ -!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? + +!!! error TS1005: '(' expected. (import.defer)("a"); - ~~~~~ -!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? + +!!! error TS1005: '(' expected. Function(import.defer); - ~~~~~ -!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? + +!!! error TS1005: '(' expected. import.defer - ~~~~~ -!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? \ No newline at end of file + +!!! error TS1005: '(' expected. \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/dynamicImportDeferInvalidStandalone.errors.txt.diff b/testdata/baselines/reference/submodule/conformance/dynamicImportDeferInvalidStandalone.errors.txt.diff deleted file mode 100644 index b61a6a6ae3..0000000000 --- a/testdata/baselines/reference/submodule/conformance/dynamicImportDeferInvalidStandalone.errors.txt.diff +++ /dev/null @@ -1,37 +0,0 @@ ---- old.dynamicImportDeferInvalidStandalone.errors.txt -+++ new.dynamicImportDeferInvalidStandalone.errors.txt -@@= skipped -0, +0 lines =@@ --b.ts(1,13): error TS1005: '(' expected. --b.ts(3,14): error TS1005: '(' expected. --b.ts(5,22): error TS1005: '(' expected. --b.ts(7,13): error TS1005: '(' expected. -+b.ts(1,8): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? -+b.ts(3,9): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? -+b.ts(5,17): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? -+b.ts(7,8): error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - - - ==== b.ts (4 errors) ==== - import.defer; -- --!!! error TS1005: '(' expected. -+ ~~~~~ -+!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - - (import.defer)("a"); -- --!!! error TS1005: '(' expected. -+ ~~~~~ -+!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - - Function(import.defer); -- --!!! error TS1005: '(' expected. -+ ~~~~~ -+!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - - import.defer -- --!!! error TS1005: '(' expected. -+ ~~~~~ -+!!! error TS17012: 'defer' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importAttributes10.errors.txt b/testdata/baselines/reference/submodule/conformance/importAttributes10.errors.txt index 922e383c71..38e981882e 100644 --- a/testdata/baselines/reference/submodule/conformance/importAttributes10.errors.txt +++ b/testdata/baselines/reference/submodule/conformance/importAttributes10.errors.txt @@ -1,11 +1,7 @@ b.ts(7,35): error TS2732: Cannot find module './a.json'. Consider using '--resolveJsonModule' to import module with '.json' extension. -b.ts(10,4): error TS1005: '}' expected. -b.ts(11,1): error TS1128: Declaration or statement expected. -b.ts(11,2): error TS1128: Declaration or statement expected. b.ts(13,35): error TS2732: Cannot find module './a.json'. Consider using '--resolveJsonModule' to import module with '.json' extension. b.ts(19,35): error TS2732: Cannot find module './a.json'. Consider using '--resolveJsonModule' to import module with '.json' extension. -b.ts(22,4): error TS1005: '}' expected. -b.ts(22,5): error TS1128: Declaration or statement expected. +b.ts(22,5): error TS1005: '}' expected. b.ts(23,1): error TS1128: Declaration or statement expected. b.ts(23,2): error TS1128: Declaration or statement expected. b.ts(25,35): error TS2732: Cannot find module './a.json'. Consider using '--resolveJsonModule' to import module with '.json' extension. @@ -15,7 +11,7 @@ b.ts(27,18): error TS1478: Identifier or string literal expected. ==== a.json (0 errors) ==== { "key": "value" } -==== b.ts (12 errors) ==== +==== b.ts (8 errors) ==== declare global { interface ImportAttributes { type: "json" @@ -28,14 +24,7 @@ b.ts(27,18): error TS1478: Identifier or string literal expected. with: { type: "json" }, - ~ -!!! error TS1005: '}' expected. -!!! related TS1007 b.ts:7:47: The parser expected to find a '}' to match the '{' token here. }); - ~ -!!! error TS1128: Declaration or statement expected. - ~ -!!! error TS1128: Declaration or statement expected. export type Test2 = typeof import("./a.json", { ~~~~~~~~~~ @@ -51,11 +40,9 @@ b.ts(27,18): error TS1478: Identifier or string literal expected. with: { type: "json" },, - ~ + ~ !!! error TS1005: '}' expected. !!! related TS1007 b.ts:19:47: The parser expected to find a '}' to match the '{' token here. - ~ -!!! error TS1128: Declaration or statement expected. }); ~ !!! error TS1128: Declaration or statement expected. diff --git a/testdata/baselines/reference/submodule/conformance/importAttributes10.errors.txt.diff b/testdata/baselines/reference/submodule/conformance/importAttributes10.errors.txt.diff index e646734e03..d0c089bb50 100644 --- a/testdata/baselines/reference/submodule/conformance/importAttributes10.errors.txt.diff +++ b/testdata/baselines/reference/submodule/conformance/importAttributes10.errors.txt.diff @@ -1,15 +1,10 @@ --- old.importAttributes10.errors.txt +++ new.importAttributes10.errors.txt @@= skipped -0, +0 lines =@@ --b.ts(22,5): error TS1005: '}' expected. +b.ts(7,35): error TS2732: Cannot find module './a.json'. Consider using '--resolveJsonModule' to import module with '.json' extension. -+b.ts(10,4): error TS1005: '}' expected. -+b.ts(11,1): error TS1128: Declaration or statement expected. -+b.ts(11,2): error TS1128: Declaration or statement expected. +b.ts(13,35): error TS2732: Cannot find module './a.json'. Consider using '--resolveJsonModule' to import module with '.json' extension. +b.ts(19,35): error TS2732: Cannot find module './a.json'. Consider using '--resolveJsonModule' to import module with '.json' extension. -+b.ts(22,4): error TS1005: '}' expected. -+b.ts(22,5): error TS1128: Declaration or statement expected. + b.ts(22,5): error TS1005: '}' expected. b.ts(23,1): error TS1128: Declaration or statement expected. b.ts(23,2): error TS1128: Declaration or statement expected. +b.ts(25,35): error TS2732: Cannot find module './a.json'. Consider using '--resolveJsonModule' to import module with '.json' extension. @@ -20,11 +15,11 @@ { "key": "value" } -==== b.ts (4 errors) ==== -+==== b.ts (12 errors) ==== ++==== b.ts (8 errors) ==== declare global { interface ImportAttributes { type: "json" -@@= skipped -14, +22 lines =@@ +@@= skipped -14, +18 lines =@@ } export type Test1 = typeof import("./a.json", { @@ -33,14 +28,7 @@ with: { type: "json" }, -+ ~ -+!!! error TS1005: '}' expected. -+!!! related TS1007 b.ts:7:47: The parser expected to find a '}' to match the '{' token here. }); -+ ~ -+!!! error TS1128: Declaration or statement expected. -+ ~ -+!!! error TS1128: Declaration or statement expected. export type Test2 = typeof import("./a.json", { + ~~~~~~~~~~ @@ -56,16 +44,7 @@ with: { type: "json" },, -- ~ -+ ~ - !!! error TS1005: '}' expected. - !!! related TS1007 b.ts:19:47: The parser expected to find a '}' to match the '{' token here. -+ ~ -+!!! error TS1128: Declaration or statement expected. - }); - ~ - !!! error TS1128: Declaration or statement expected. -@@= skipped -25, +40 lines =@@ +@@= skipped -25, +31 lines =@@ !!! error TS1128: Declaration or statement expected. export type Test4 = typeof import("./a.json", { diff --git a/testdata/baselines/reference/submodule/conformance/importAttributes10.js b/testdata/baselines/reference/submodule/conformance/importAttributes10.js index 8413c8b3b1..85768b224f 100644 --- a/testdata/baselines/reference/submodule/conformance/importAttributes10.js +++ b/testdata/baselines/reference/submodule/conformance/importAttributes10.js @@ -39,4 +39,3 @@ export type Test4 = typeof import("./a.json", { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); ; -; diff --git a/testdata/baselines/reference/submodule/conformance/importAttributes10.js.diff b/testdata/baselines/reference/submodule/conformance/importAttributes10.js.diff deleted file mode 100644 index f7c9d71ea3..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importAttributes10.js.diff +++ /dev/null @@ -1,7 +0,0 @@ ---- old.importAttributes10.js -+++ new.importAttributes10.js -@@= skipped -38, +38 lines =@@ - "use strict"; - Object.defineProperty(exports, "__esModule", { value: true }); - ; -+; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferComments.errors.txt b/testdata/baselines/reference/submodule/conformance/importDeferComments.errors.txt index ff4f566096..56b486f834 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferComments.errors.txt +++ b/testdata/baselines/reference/submodule/conformance/importDeferComments.errors.txt @@ -1,26 +1,11 @@ -b.ts(1,32): error TS1005: '=' expected. -b.ts(1,40): error TS2304: Cannot find name 'as'. -b.ts(1,49): error TS1005: ';' expected. -b.ts(1,49): error TS2304: Cannot find name 'aNs'. -b.ts(1,59): error TS1434: Unexpected keyword or identifier. -b.ts(1,59): error TS2304: Cannot find name 'from'. +b.ts(1,70): error TS2307: Cannot find module 'a' or its corresponding type declarations. ==== a.ts (0 errors) ==== export {}; -==== b.ts (6 errors) ==== +==== b.ts (1 errors) ==== /*1*/ import /*2*/ defer /*3*/ * /*4*/ as /*5*/ aNs /*6*/ from /*7*/ "a" /*8*/; - ~ -!!! error TS1005: '=' expected. - ~~ -!!! error TS2304: Cannot find name 'as'. - ~~~ -!!! error TS1005: ';' expected. - ~~~ -!!! error TS2304: Cannot find name 'aNs'. - ~~~~ -!!! error TS1434: Unexpected keyword or identifier. - ~~~~ -!!! error TS2304: Cannot find name 'from'. + ~~~ +!!! error TS2307: Cannot find module 'a' or its corresponding type declarations. \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferComments.errors.txt.diff b/testdata/baselines/reference/submodule/conformance/importDeferComments.errors.txt.diff index 2a5d428880..9cf02c2d3d 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferComments.errors.txt.diff +++ b/testdata/baselines/reference/submodule/conformance/importDeferComments.errors.txt.diff @@ -2,29 +2,14 @@ +++ new.importDeferComments.errors.txt @@= skipped -0, +0 lines =@@ - -+b.ts(1,32): error TS1005: '=' expected. -+b.ts(1,40): error TS2304: Cannot find name 'as'. -+b.ts(1,49): error TS1005: ';' expected. -+b.ts(1,49): error TS2304: Cannot find name 'aNs'. -+b.ts(1,59): error TS1434: Unexpected keyword or identifier. -+b.ts(1,59): error TS2304: Cannot find name 'from'. ++b.ts(1,70): error TS2307: Cannot find module 'a' or its corresponding type declarations. + + +==== a.ts (0 errors) ==== + export {}; + -+==== b.ts (6 errors) ==== ++==== b.ts (1 errors) ==== + /*1*/ import /*2*/ defer /*3*/ * /*4*/ as /*5*/ aNs /*6*/ from /*7*/ "a" /*8*/; -+ ~ -+!!! error TS1005: '=' expected. -+ ~~ -+!!! error TS2304: Cannot find name 'as'. -+ ~~~ -+!!! error TS1005: ';' expected. -+ ~~~ -+!!! error TS2304: Cannot find name 'aNs'. -+ ~~~~ -+!!! error TS1434: Unexpected keyword or identifier. -+ ~~~~ -+!!! error TS2304: Cannot find name 'from'. ++ ~~~ ++!!! error TS2307: Cannot find module 'a' or its corresponding type declarations. + \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferComments.js b/testdata/baselines/reference/submodule/conformance/importDeferComments.js index 1cc0b76b41..3e7980dbc1 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferComments.js +++ b/testdata/baselines/reference/submodule/conformance/importDeferComments.js @@ -10,7 +10,4 @@ export {}; //// [a.js] export {}; //// [b.js] - * /*4*/ as; /*5*/ -aNs; /*6*/ -from; /*7*/ -"a" /*8*/; +export {}; diff --git a/testdata/baselines/reference/submodule/conformance/importDeferComments.js.diff b/testdata/baselines/reference/submodule/conformance/importDeferComments.js.diff deleted file mode 100644 index 3cc524326d..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferComments.js.diff +++ /dev/null @@ -1,11 +0,0 @@ ---- old.importDeferComments.js -+++ new.importDeferComments.js -@@= skipped -9, +9 lines =@@ - //// [a.js] - export {}; - //// [b.js] --export {}; -+ * /*4*/ as; /*5*/ -+aNs; /*6*/ -+from; /*7*/ -+"a" /*8*/; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferComments.symbols b/testdata/baselines/reference/submodule/conformance/importDeferComments.symbols index c409bcae8c..fec1187392 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferComments.symbols +++ b/testdata/baselines/reference/submodule/conformance/importDeferComments.symbols @@ -6,5 +6,5 @@ export {}; === b.ts === /*1*/ import /*2*/ defer /*3*/ * /*4*/ as /*5*/ aNs /*6*/ from /*7*/ "a" /*8*/; ->defer : Symbol(defer, Decl(b.ts, 0, 0)) +>aNs : Symbol(aNs, Decl(b.ts, 0, 24)) diff --git a/testdata/baselines/reference/submodule/conformance/importDeferComments.symbols.diff b/testdata/baselines/reference/submodule/conformance/importDeferComments.symbols.diff deleted file mode 100644 index bb584157e2..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferComments.symbols.diff +++ /dev/null @@ -1,8 +0,0 @@ ---- old.importDeferComments.symbols -+++ new.importDeferComments.symbols -@@= skipped -5, +5 lines =@@ - - === b.ts === - /*1*/ import /*2*/ defer /*3*/ * /*4*/ as /*5*/ aNs /*6*/ from /*7*/ "a" /*8*/; -->aNs : Symbol(aNs, Decl(b.ts, 0, 24)) -+>defer : Symbol(defer, Decl(b.ts, 0, 0)) diff --git a/testdata/baselines/reference/submodule/conformance/importDeferComments.types b/testdata/baselines/reference/submodule/conformance/importDeferComments.types index 0535519e58..1a030171c0 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferComments.types +++ b/testdata/baselines/reference/submodule/conformance/importDeferComments.types @@ -6,12 +6,5 @@ export {}; === b.ts === /*1*/ import /*2*/ defer /*3*/ * /*4*/ as /*5*/ aNs /*6*/ from /*7*/ "a" /*8*/; ->defer : any -> : any ->* /*4*/ as : number -> : any ->as : any >aNs : any ->from : any ->"a" : "a" diff --git a/testdata/baselines/reference/submodule/conformance/importDeferComments.types.diff b/testdata/baselines/reference/submodule/conformance/importDeferComments.types.diff index 81b051e43d..9a344a8478 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferComments.types.diff +++ b/testdata/baselines/reference/submodule/conformance/importDeferComments.types.diff @@ -5,11 +5,4 @@ === b.ts === /*1*/ import /*2*/ defer /*3*/ * /*4*/ as /*5*/ aNs /*6*/ from /*7*/ "a" /*8*/; ->aNs : typeof aNs -+>defer : any -+> : any -+>* /*4*/ as : number -+> : any -+>as : any +>aNs : any -+>from : any -+>"a" : "a" diff --git a/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.errors.txt b/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.errors.txt deleted file mode 100644 index f2197642db..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.errors.txt +++ /dev/null @@ -1,33 +0,0 @@ -b.ts(1,14): error TS1005: '=' expected. -b.ts(1,16): error TS2304: Cannot find name 'as'. -b.ts(1,19): error TS1005: ';' expected. -b.ts(1,19): error TS2304: Cannot find name 'ns'. -b.ts(1,22): error TS1434: Unexpected keyword or identifier. -b.ts(1,22): error TS2304: Cannot find name 'from'. -b.ts(3,24): error TS2503: Cannot find namespace 'ns'. - - -==== a.ts (0 errors) ==== - export interface Foo { - x: number; - } - -==== b.ts (7 errors) ==== - import defer * as ns from "./a.js"; - ~ -!!! error TS1005: '=' expected. - ~~ -!!! error TS2304: Cannot find name 'as'. - ~~ -!!! error TS1005: ';' expected. - ~~ -!!! error TS2304: Cannot find name 'ns'. - ~~~~ -!!! error TS1434: Unexpected keyword or identifier. - ~~~~ -!!! error TS2304: Cannot find name 'from'. - - export type X = { foo: ns.Foo }; - ~~ -!!! error TS2503: Cannot find namespace 'ns'. - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.errors.txt.diff b/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.errors.txt.diff deleted file mode 100644 index bd03a889b2..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.errors.txt.diff +++ /dev/null @@ -1,37 +0,0 @@ ---- old.importDeferDeclaration.errors.txt -+++ new.importDeferDeclaration.errors.txt -@@= skipped -0, +0 lines =@@ -- -+b.ts(1,14): error TS1005: '=' expected. -+b.ts(1,16): error TS2304: Cannot find name 'as'. -+b.ts(1,19): error TS1005: ';' expected. -+b.ts(1,19): error TS2304: Cannot find name 'ns'. -+b.ts(1,22): error TS1434: Unexpected keyword or identifier. -+b.ts(1,22): error TS2304: Cannot find name 'from'. -+b.ts(3,24): error TS2503: Cannot find namespace 'ns'. -+ -+ -+==== a.ts (0 errors) ==== -+ export interface Foo { -+ x: number; -+ } -+ -+==== b.ts (7 errors) ==== -+ import defer * as ns from "./a.js"; -+ ~ -+!!! error TS1005: '=' expected. -+ ~~ -+!!! error TS2304: Cannot find name 'as'. -+ ~~ -+!!! error TS1005: ';' expected. -+ ~~ -+!!! error TS2304: Cannot find name 'ns'. -+ ~~~~ -+!!! error TS1434: Unexpected keyword or identifier. -+ ~~~~ -+!!! error TS2304: Cannot find name 'from'. -+ -+ export type X = { foo: ns.Foo }; -+ ~~ -+!!! error TS2503: Cannot find namespace 'ns'. -+ \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.js b/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.js index 76d0f7cdf9..55175f4b65 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.js +++ b/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.js @@ -14,10 +14,6 @@ export type X = { foo: ns.Foo }; //// [a.js] export {}; //// [b.js] - * as; -ns; -from; -"./a.js"; export {}; @@ -26,6 +22,7 @@ export interface Foo { x: number; } //// [b.d.ts] +import * as ns from "./a.js"; export type X = { foo: ns.Foo; }; diff --git a/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.js.diff b/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.js.diff deleted file mode 100644 index 6870f66b26..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.js.diff +++ /dev/null @@ -1,21 +0,0 @@ ---- old.importDeferDeclaration.js -+++ new.importDeferDeclaration.js -@@= skipped -13, +13 lines =@@ - //// [a.js] - export {}; - //// [b.js] -+ * as; -+ns; -+from; -+"./a.js"; - export {}; - - -@@= skipped -8, +12 lines =@@ - x: number; - } - //// [b.d.ts] --import * as ns from "./a.js"; - export type X = { - foo: ns.Foo; - }; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.symbols b/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.symbols index cde1621d98..9518404d16 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.symbols +++ b/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.symbols @@ -10,11 +10,11 @@ export interface Foo { === b.ts === import defer * as ns from "./a.js"; ->defer : Symbol(defer, Decl(b.ts, 0, 0)) +>ns : Symbol(ns, Decl(b.ts, 0, 12)) export type X = { foo: ns.Foo }; >X : Symbol(X, Decl(b.ts, 0, 35)) >foo : Symbol(foo, Decl(b.ts, 2, 17)) ->ns : Symbol(ns) ->Foo : Symbol(ns.Foo) +>ns : Symbol(ns, Decl(b.ts, 0, 12)) +>Foo : Symbol(ns.Foo, Decl(a.ts, 0, 0)) diff --git a/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.symbols.diff b/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.symbols.diff deleted file mode 100644 index 0d94c1d8f1..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.symbols.diff +++ /dev/null @@ -1,16 +0,0 @@ ---- old.importDeferDeclaration.symbols -+++ new.importDeferDeclaration.symbols -@@= skipped -9, +9 lines =@@ - - === b.ts === - import defer * as ns from "./a.js"; -->ns : Symbol(ns, Decl(b.ts, 0, 12)) -+>defer : Symbol(defer, Decl(b.ts, 0, 0)) - - export type X = { foo: ns.Foo }; - >X : Symbol(X, Decl(b.ts, 0, 35)) - >foo : Symbol(foo, Decl(b.ts, 2, 17)) -->ns : Symbol(ns, Decl(b.ts, 0, 12)) -->Foo : Symbol(ns.Foo, Decl(a.ts, 0, 0)) -+>ns : Symbol(ns) -+>Foo : Symbol(ns.Foo) diff --git a/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.types b/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.types index 72743922ec..a66185477d 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.types +++ b/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.types @@ -8,14 +8,7 @@ export interface Foo { === b.ts === import defer * as ns from "./a.js"; ->defer : any -> : any ->* as : number -> : any ->as : any ->ns : any ->from : any ->"./a.js" : "./a.js" +>ns : typeof ns export type X = { foo: ns.Foo }; >X : X diff --git a/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.types.diff b/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.types.diff deleted file mode 100644 index 3a8bca7261..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferDeclaration.types.diff +++ /dev/null @@ -1,18 +0,0 @@ ---- old.importDeferDeclaration.types -+++ new.importDeferDeclaration.types -@@= skipped -7, +7 lines =@@ - - === b.ts === - import defer * as ns from "./a.js"; -->ns : typeof ns -+>defer : any -+> : any -+>* as : number -+> : any -+>as : any -+>ns : any -+>from : any -+>"./a.js" : "./a.js" - - export type X = { foo: ns.Foo }; - >X : X \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.errors.txt b/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.errors.txt index 514c4ff861..5a82911a23 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.errors.txt +++ b/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.errors.txt @@ -1,14 +1,11 @@ -b.ts(1,19): error TS1141: String literal expected. -b.ts(1,24): error TS1005: ';' expected. +b.ts(1,8): error TS18058: Default imports are not allowed in a deferred import. ==== a.ts (0 errors) ==== export default 2; -==== b.ts (2 errors) ==== +==== b.ts (1 errors) ==== import defer from from "./a.js"; - ~~~~ -!!! error TS1141: String literal expected. - ~~~~~~~~ -!!! error TS1005: ';' expected. + ~~~~~~~~~~ +!!! error TS18058: Default imports are not allowed in a deferred import. \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.errors.txt.diff b/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.errors.txt.diff deleted file mode 100644 index 83b7734f4a..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.errors.txt.diff +++ /dev/null @@ -1,21 +0,0 @@ ---- old.importDeferFromInvalid.errors.txt -+++ new.importDeferFromInvalid.errors.txt -@@= skipped -0, +0 lines =@@ --b.ts(1,8): error TS18058: Default imports are not allowed in a deferred import. -+b.ts(1,19): error TS1141: String literal expected. -+b.ts(1,24): error TS1005: ';' expected. - - - ==== a.ts (0 errors) ==== - export default 2; - --==== b.ts (1 errors) ==== -+==== b.ts (2 errors) ==== - import defer from from "./a.js"; -- ~~~~~~~~~~ --!!! error TS18058: Default imports are not allowed in a deferred import. -+ ~~~~ -+!!! error TS1141: String literal expected. -+ ~~~~~~~~ -+!!! error TS1005: ';' expected. - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.js b/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.js index 56ecb26e5a..3ca6148749 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.js +++ b/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.js @@ -10,5 +10,4 @@ import defer from from "./a.js"; //// [a.js] export default 2; //// [b.js] -"./a.js"; export {}; diff --git a/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.js.diff b/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.js.diff deleted file mode 100644 index a4ac952753..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.js.diff +++ /dev/null @@ -1,8 +0,0 @@ ---- old.importDeferFromInvalid.js -+++ new.importDeferFromInvalid.js -@@= skipped -9, +9 lines =@@ - //// [a.js] - export default 2; - //// [b.js] -+"./a.js"; - export {}; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.symbols b/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.symbols index b3d6c68c4f..6060cd3a13 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.symbols +++ b/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.symbols @@ -6,5 +6,5 @@ export default 2; === b.ts === import defer from from "./a.js"; ->defer : Symbol(defer, Decl(b.ts, 0, 6)) +>from : Symbol(from, Decl(b.ts, 0, 6)) diff --git a/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.symbols.diff b/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.symbols.diff deleted file mode 100644 index 5c4a23f0e6..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.symbols.diff +++ /dev/null @@ -1,8 +0,0 @@ ---- old.importDeferFromInvalid.symbols -+++ new.importDeferFromInvalid.symbols -@@= skipped -5, +5 lines =@@ - - === b.ts === - import defer from from "./a.js"; -->from : Symbol(from, Decl(b.ts, 0, 6)) -+>defer : Symbol(defer, Decl(b.ts, 0, 6)) diff --git a/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.types b/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.types index d37e7dadd3..71e1f02605 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.types +++ b/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.types @@ -6,7 +6,5 @@ export default 2; === b.ts === import defer from from "./a.js"; ->defer : any ->from : any ->"./a.js" : "./a.js" +>from : 2 diff --git a/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.types.diff b/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.types.diff deleted file mode 100644 index c8413a65d8..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferFromInvalid.types.diff +++ /dev/null @@ -1,10 +0,0 @@ ---- old.importDeferFromInvalid.types -+++ new.importDeferFromInvalid.types -@@= skipped -5, +5 lines =@@ - - === b.ts === - import defer from from "./a.js"; -->from : 2 -+>defer : any -+>from : any -+>"./a.js" : "./a.js" diff --git a/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.errors.txt b/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.errors.txt index 85d6fe7874..98b01b7145 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.errors.txt +++ b/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.errors.txt @@ -1,8 +1,5 @@ -b.ts(1,14): error TS1005: '=' expected. -b.ts(1,14): error TS2503: Cannot find namespace 'foo'. -b.ts(1,18): error TS1005: ';' expected. -b.ts(1,18): error TS2304: Cannot find name 'from'. -b.ts(3,1): error TS2304: Cannot find name 'foo'. +b.ts(1,8): error TS18058: Default imports are not allowed in a deferred import. +b.ts(1,23): error TS2307: Cannot find module 'a' or its corresponding type declarations. ==== a.ts (0 errors) ==== @@ -10,17 +7,11 @@ b.ts(3,1): error TS2304: Cannot find name 'foo'. console.log("foo from a"); } -==== b.ts (5 errors) ==== +==== b.ts (2 errors) ==== import defer foo from "a"; - ~~~ -!!! error TS1005: '=' expected. - ~~~ -!!! error TS2503: Cannot find namespace 'foo'. - ~~~~ -!!! error TS1005: ';' expected. - ~~~~ -!!! error TS2304: Cannot find name 'from'. + ~~~~~~~~~ +!!! error TS18058: Default imports are not allowed in a deferred import. + ~~~ +!!! error TS2307: Cannot find module 'a' or its corresponding type declarations. - foo(); - ~~~ -!!! error TS2304: Cannot find name 'foo'. \ No newline at end of file + foo(); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.errors.txt.diff b/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.errors.txt.diff index 3cf4427984..380c23e525 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.errors.txt.diff +++ b/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.errors.txt.diff @@ -1,33 +1,21 @@ --- old.importDeferInvalidDefault.errors.txt +++ new.importDeferInvalidDefault.errors.txt @@= skipped -0, +0 lines =@@ --b.ts(1,8): error TS18058: Default imports are not allowed in a deferred import. -+b.ts(1,14): error TS1005: '=' expected. -+b.ts(1,14): error TS2503: Cannot find namespace 'foo'. -+b.ts(1,18): error TS1005: ';' expected. -+b.ts(1,18): error TS2304: Cannot find name 'from'. -+b.ts(3,1): error TS2304: Cannot find name 'foo'. + b.ts(1,8): error TS18058: Default imports are not allowed in a deferred import. ++b.ts(1,23): error TS2307: Cannot find module 'a' or its corresponding type declarations. ==== a.ts (0 errors) ==== -@@= skipped -5, +9 lines =@@ +@@= skipped -5, +6 lines =@@ console.log("foo from a"); } -==== b.ts (1 errors) ==== -+==== b.ts (5 errors) ==== ++==== b.ts (2 errors) ==== import defer foo from "a"; -- ~~~~~~~~~ --!!! error TS18058: Default imports are not allowed in a deferred import. -+ ~~~ -+!!! error TS1005: '=' expected. -+ ~~~ -+!!! error TS2503: Cannot find namespace 'foo'. -+ ~~~~ -+!!! error TS1005: ';' expected. -+ ~~~~ -+!!! error TS2304: Cannot find name 'from'. + ~~~~~~~~~ + !!! error TS18058: Default imports are not allowed in a deferred import. ++ ~~~ ++!!! error TS2307: Cannot find module 'a' or its corresponding type declarations. - foo(); -+ ~~~ -+!!! error TS2304: Cannot find name 'foo'. \ No newline at end of file + foo(); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.js b/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.js index 3ef7569e46..e0f3491c63 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.js +++ b/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.js @@ -15,6 +15,5 @@ export default function foo() { console.log("foo from a"); } //// [b.js] -from; -"a"; +import defer foo from "a"; foo(); diff --git a/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.js.diff b/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.js.diff deleted file mode 100644 index cf18f63001..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.js.diff +++ /dev/null @@ -1,10 +0,0 @@ ---- old.importDeferInvalidDefault.js -+++ new.importDeferInvalidDefault.js -@@= skipped -14, +14 lines =@@ - console.log("foo from a"); - } - //// [b.js] --import defer foo from "a"; -+from; -+"a"; - foo(); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.symbols b/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.symbols index 7aff09c746..dd548fc593 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.symbols +++ b/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.symbols @@ -12,6 +12,8 @@ export default function foo() { === b.ts === import defer foo from "a"; ->defer : Symbol(defer, Decl(b.ts, 0, 0)) +>foo : Symbol(foo, Decl(b.ts, 0, 6)) foo(); +>foo : Symbol(foo, Decl(b.ts, 0, 6)) + diff --git a/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.symbols.diff b/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.symbols.diff deleted file mode 100644 index 8323066273..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.symbols.diff +++ /dev/null @@ -1,12 +0,0 @@ ---- old.importDeferInvalidDefault.symbols -+++ new.importDeferInvalidDefault.symbols -@@= skipped -11, +11 lines =@@ - - === b.ts === - import defer foo from "a"; -->foo : Symbol(foo, Decl(b.ts, 0, 6)) -+>defer : Symbol(defer, Decl(b.ts, 0, 0)) - - foo(); -->foo : Symbol(foo, Decl(b.ts, 0, 6)) -- \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.types b/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.types index a0e1a83b2f..a9b9e63190 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.types +++ b/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.types @@ -14,10 +14,7 @@ export default function foo() { === b.ts === import defer foo from "a"; ->defer : any >foo : any ->from : any ->"a" : "a" foo(); >foo() : any diff --git a/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.types.diff b/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.types.diff index ce62a48481..f0c844e7c9 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.types.diff +++ b/testdata/baselines/reference/submodule/conformance/importDeferInvalidDefault.types.diff @@ -5,10 +5,7 @@ === b.ts === import defer foo from "a"; ->foo : () => void -+>defer : any +>foo : any -+>from : any -+>"a" : "a" foo(); ->foo() : void diff --git a/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.errors.txt b/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.errors.txt index 65e2aa11dd..4670b0cf31 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.errors.txt +++ b/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.errors.txt @@ -1,8 +1,5 @@ -b.ts(1,14): error TS1005: '=' expected. -b.ts(1,16): error TS2304: Cannot find name 'foo'. -b.ts(1,22): error TS1434: Unexpected keyword or identifier. -b.ts(1,22): error TS2304: Cannot find name 'from'. -b.ts(3,1): error TS2304: Cannot find name 'foo'. +b.ts(1,8): error TS18059: Named imports are not allowed in a deferred import. +b.ts(1,27): error TS2307: Cannot find module 'a' or its corresponding type declarations. ==== a.ts (0 errors) ==== @@ -10,17 +7,11 @@ b.ts(3,1): error TS2304: Cannot find name 'foo'. console.log("foo from a"); } -==== b.ts (5 errors) ==== +==== b.ts (2 errors) ==== import defer { foo } from "a"; - ~ -!!! error TS1005: '=' expected. - ~~~ -!!! error TS2304: Cannot find name 'foo'. - ~~~~ -!!! error TS1434: Unexpected keyword or identifier. - ~~~~ -!!! error TS2304: Cannot find name 'from'. + ~~~~~~~~~~~~~ +!!! error TS18059: Named imports are not allowed in a deferred import. + ~~~ +!!! error TS2307: Cannot find module 'a' or its corresponding type declarations. - foo(); - ~~~ -!!! error TS2304: Cannot find name 'foo'. \ No newline at end of file + foo(); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.errors.txt.diff b/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.errors.txt.diff index fd9ab8ee53..4f150de2ce 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.errors.txt.diff +++ b/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.errors.txt.diff @@ -1,33 +1,21 @@ --- old.importDeferInvalidNamed.errors.txt +++ new.importDeferInvalidNamed.errors.txt @@= skipped -0, +0 lines =@@ --b.ts(1,8): error TS18059: Named imports are not allowed in a deferred import. -+b.ts(1,14): error TS1005: '=' expected. -+b.ts(1,16): error TS2304: Cannot find name 'foo'. -+b.ts(1,22): error TS1434: Unexpected keyword or identifier. -+b.ts(1,22): error TS2304: Cannot find name 'from'. -+b.ts(3,1): error TS2304: Cannot find name 'foo'. + b.ts(1,8): error TS18059: Named imports are not allowed in a deferred import. ++b.ts(1,27): error TS2307: Cannot find module 'a' or its corresponding type declarations. ==== a.ts (0 errors) ==== -@@= skipped -5, +9 lines =@@ +@@= skipped -5, +6 lines =@@ console.log("foo from a"); } -==== b.ts (1 errors) ==== -+==== b.ts (5 errors) ==== ++==== b.ts (2 errors) ==== import defer { foo } from "a"; -- ~~~~~~~~~~~~~ --!!! error TS18059: Named imports are not allowed in a deferred import. -+ ~ -+!!! error TS1005: '=' expected. -+ ~~~ -+!!! error TS2304: Cannot find name 'foo'. -+ ~~~~ -+!!! error TS1434: Unexpected keyword or identifier. -+ ~~~~ -+!!! error TS2304: Cannot find name 'from'. + ~~~~~~~~~~~~~ + !!! error TS18059: Named imports are not allowed in a deferred import. ++ ~~~ ++!!! error TS2307: Cannot find module 'a' or its corresponding type declarations. - foo(); -+ ~~~ -+!!! error TS2304: Cannot find name 'foo'. \ No newline at end of file + foo(); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.js b/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.js index b007a9b528..8f92f52fa0 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.js +++ b/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.js @@ -15,9 +15,5 @@ export function foo() { console.log("foo from a"); } //// [b.js] -{ - foo; -} -from; -"a"; +import defer { foo } from "a"; foo(); diff --git a/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.js.diff b/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.js.diff deleted file mode 100644 index a5b3b47cb5..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.js.diff +++ /dev/null @@ -1,13 +0,0 @@ ---- old.importDeferInvalidNamed.js -+++ new.importDeferInvalidNamed.js -@@= skipped -14, +14 lines =@@ - console.log("foo from a"); - } - //// [b.js] --import defer { foo } from "a"; -+{ -+ foo; -+} -+from; -+"a"; - foo(); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.symbols b/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.symbols index 7568b6ab81..77f3959cd7 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.symbols +++ b/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.symbols @@ -12,6 +12,8 @@ export function foo() { === b.ts === import defer { foo } from "a"; ->defer : Symbol(defer, Decl(b.ts, 0, 0)) +>foo : Symbol(foo, Decl(b.ts, 0, 14)) foo(); +>foo : Symbol(foo, Decl(b.ts, 0, 14)) + diff --git a/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.symbols.diff b/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.symbols.diff deleted file mode 100644 index f88b7ba200..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.symbols.diff +++ /dev/null @@ -1,12 +0,0 @@ ---- old.importDeferInvalidNamed.symbols -+++ new.importDeferInvalidNamed.symbols -@@= skipped -11, +11 lines =@@ - - === b.ts === - import defer { foo } from "a"; -->foo : Symbol(foo, Decl(b.ts, 0, 14)) -+>defer : Symbol(defer, Decl(b.ts, 0, 0)) - - foo(); -->foo : Symbol(foo, Decl(b.ts, 0, 14)) -- \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.types b/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.types index fed70aa3c7..6263341dcc 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.types +++ b/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.types @@ -14,11 +14,7 @@ export function foo() { === b.ts === import defer { foo } from "a"; ->defer : any -> : any >foo : any ->from : any ->"a" : "a" foo(); >foo() : any diff --git a/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.types.diff b/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.types.diff index 61dd9e198e..5b1085115d 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.types.diff +++ b/testdata/baselines/reference/submodule/conformance/importDeferInvalidNamed.types.diff @@ -5,11 +5,7 @@ === b.ts === import defer { foo } from "a"; ->foo : () => void -+>defer : any -+> : any +>foo : any -+>from : any -+>"a" : "a" foo(); ->foo() : void diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).errors.txt b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).errors.txt index e7c04cb2ea..74c011b13a 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).errors.txt +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).errors.txt @@ -1,10 +1,4 @@ -b.ts(1,14): error TS1005: '=' expected. -b.ts(1,16): error TS2304: Cannot find name 'as'. -b.ts(1,19): error TS1005: ';' expected. -b.ts(1,19): error TS2304: Cannot find name 'aNs'. -b.ts(1,23): error TS1434: Unexpected keyword or identifier. -b.ts(1,23): error TS2304: Cannot find name 'from'. -b.ts(3,1): error TS2304: Cannot find name 'aNs'. +b.ts(1,8): error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. ==== a.ts (0 errors) ==== @@ -12,21 +6,9 @@ b.ts(3,1): error TS2304: Cannot find name 'aNs'. console.log("foo from a"); } -==== b.ts (7 errors) ==== +==== b.ts (1 errors) ==== import defer * as aNs from "./a.js"; - ~ -!!! error TS1005: '=' expected. - ~~ -!!! error TS2304: Cannot find name 'as'. - ~~~ -!!! error TS1005: ';' expected. - ~~~ -!!! error TS2304: Cannot find name 'aNs'. - ~~~~ -!!! error TS1434: Unexpected keyword or identifier. - ~~~~ -!!! error TS2304: Cannot find name 'from'. + ~~~~~~~~~~~~~~ +!!! error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. - aNs.foo(); - ~~~ -!!! error TS2304: Cannot find name 'aNs'. \ No newline at end of file + aNs.foo(); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).errors.txt.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).errors.txt.diff deleted file mode 100644 index e52068586c..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).errors.txt.diff +++ /dev/null @@ -1,39 +0,0 @@ ---- old.importDeferNamespace(module=commonjs).errors.txt -+++ new.importDeferNamespace(module=commonjs).errors.txt -@@= skipped -0, +0 lines =@@ --b.ts(1,8): error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. -+b.ts(1,14): error TS1005: '=' expected. -+b.ts(1,16): error TS2304: Cannot find name 'as'. -+b.ts(1,19): error TS1005: ';' expected. -+b.ts(1,19): error TS2304: Cannot find name 'aNs'. -+b.ts(1,23): error TS1434: Unexpected keyword or identifier. -+b.ts(1,23): error TS2304: Cannot find name 'from'. -+b.ts(3,1): error TS2304: Cannot find name 'aNs'. - - - ==== a.ts (0 errors) ==== -@@= skipped -5, +11 lines =@@ - console.log("foo from a"); - } - --==== b.ts (1 errors) ==== -+==== b.ts (7 errors) ==== - import defer * as aNs from "./a.js"; -- ~~~~~~~~~~~~~~ --!!! error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. -+ ~ -+!!! error TS1005: '=' expected. -+ ~~ -+!!! error TS2304: Cannot find name 'as'. -+ ~~~ -+!!! error TS1005: ';' expected. -+ ~~~ -+!!! error TS2304: Cannot find name 'aNs'. -+ ~~~~ -+!!! error TS1434: Unexpected keyword or identifier. -+ ~~~~ -+!!! error TS2304: Cannot find name 'from'. - - aNs.foo(); -+ ~~~ -+!!! error TS2304: Cannot find name 'aNs'. \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).js b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).js index f05106969d..181c471732 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).js +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).js @@ -18,8 +18,7 @@ function foo() { console.log("foo from a"); } //// [b.js] - * as; -aNs; -from; -"./a.js"; +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const aNs = require("./a.js"); aNs.foo(); diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).js.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).js.diff deleted file mode 100644 index 1eb0aef9d2..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).js.diff +++ /dev/null @@ -1,14 +0,0 @@ ---- old.importDeferNamespace(module=commonjs).js -+++ new.importDeferNamespace(module=commonjs).js -@@= skipped -17, +17 lines =@@ - console.log("foo from a"); - } - //// [b.js] --"use strict"; --Object.defineProperty(exports, "__esModule", { value: true }); --const aNs = require("./a.js"); -+ * as; -+aNs; -+from; -+"./a.js"; - aNs.foo(); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).symbols b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).symbols index 2cbec9e857..eca0a04a77 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).symbols +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).symbols @@ -12,6 +12,10 @@ export function foo() { === b.ts === import defer * as aNs from "./a.js"; ->defer : Symbol(defer, Decl(b.ts, 0, 0)) +>aNs : Symbol(aNs, Decl(b.ts, 0, 12)) aNs.foo(); +>aNs.foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) +>aNs : Symbol(aNs, Decl(b.ts, 0, 12)) +>foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) + diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).symbols.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).symbols.diff deleted file mode 100644 index 9aa19f6746..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).symbols.diff +++ /dev/null @@ -1,14 +0,0 @@ ---- old.importDeferNamespace(module=commonjs).symbols -+++ new.importDeferNamespace(module=commonjs).symbols -@@= skipped -11, +11 lines =@@ - - === b.ts === - import defer * as aNs from "./a.js"; -->aNs : Symbol(aNs, Decl(b.ts, 0, 12)) -+>defer : Symbol(defer, Decl(b.ts, 0, 0)) - - aNs.foo(); -->aNs.foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) -->aNs : Symbol(aNs, Decl(b.ts, 0, 12)) -->foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) -- \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).types b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).types index 0222a6c0b7..ea6e0a8783 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).types +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).types @@ -14,18 +14,11 @@ export function foo() { === b.ts === import defer * as aNs from "./a.js"; ->defer : any -> : any ->* as : number -> : any ->as : any ->aNs : any ->from : any ->"./a.js" : "./a.js" +>aNs : typeof aNs aNs.foo(); ->aNs.foo() : any ->aNs.foo : any ->aNs : any ->foo : any +>aNs.foo() : void +>aNs.foo : () => void +>aNs : typeof aNs +>foo : () => void diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).types.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).types.diff deleted file mode 100644 index 378f536ccd..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=commonjs).types.diff +++ /dev/null @@ -1,25 +0,0 @@ ---- old.importDeferNamespace(module=commonjs).types -+++ new.importDeferNamespace(module=commonjs).types -@@= skipped -13, +13 lines =@@ - - === b.ts === - import defer * as aNs from "./a.js"; -->aNs : typeof aNs -+>defer : any -+> : any -+>* as : number -+> : any -+>as : any -+>aNs : any -+>from : any -+>"./a.js" : "./a.js" - - aNs.foo(); -->aNs.foo() : void -->aNs.foo : () => void -->aNs : typeof aNs -->foo : () => void -+>aNs.foo() : any -+>aNs.foo : any -+>aNs : any -+>foo : any diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).errors.txt b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).errors.txt index e7c04cb2ea..74c011b13a 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).errors.txt +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).errors.txt @@ -1,10 +1,4 @@ -b.ts(1,14): error TS1005: '=' expected. -b.ts(1,16): error TS2304: Cannot find name 'as'. -b.ts(1,19): error TS1005: ';' expected. -b.ts(1,19): error TS2304: Cannot find name 'aNs'. -b.ts(1,23): error TS1434: Unexpected keyword or identifier. -b.ts(1,23): error TS2304: Cannot find name 'from'. -b.ts(3,1): error TS2304: Cannot find name 'aNs'. +b.ts(1,8): error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. ==== a.ts (0 errors) ==== @@ -12,21 +6,9 @@ b.ts(3,1): error TS2304: Cannot find name 'aNs'. console.log("foo from a"); } -==== b.ts (7 errors) ==== +==== b.ts (1 errors) ==== import defer * as aNs from "./a.js"; - ~ -!!! error TS1005: '=' expected. - ~~ -!!! error TS2304: Cannot find name 'as'. - ~~~ -!!! error TS1005: ';' expected. - ~~~ -!!! error TS2304: Cannot find name 'aNs'. - ~~~~ -!!! error TS1434: Unexpected keyword or identifier. - ~~~~ -!!! error TS2304: Cannot find name 'from'. + ~~~~~~~~~~~~~~ +!!! error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. - aNs.foo(); - ~~~ -!!! error TS2304: Cannot find name 'aNs'. \ No newline at end of file + aNs.foo(); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).errors.txt.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).errors.txt.diff deleted file mode 100644 index 67c18b2aee..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).errors.txt.diff +++ /dev/null @@ -1,39 +0,0 @@ ---- old.importDeferNamespace(module=es2015).errors.txt -+++ new.importDeferNamespace(module=es2015).errors.txt -@@= skipped -0, +0 lines =@@ --b.ts(1,8): error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. -+b.ts(1,14): error TS1005: '=' expected. -+b.ts(1,16): error TS2304: Cannot find name 'as'. -+b.ts(1,19): error TS1005: ';' expected. -+b.ts(1,19): error TS2304: Cannot find name 'aNs'. -+b.ts(1,23): error TS1434: Unexpected keyword or identifier. -+b.ts(1,23): error TS2304: Cannot find name 'from'. -+b.ts(3,1): error TS2304: Cannot find name 'aNs'. - - - ==== a.ts (0 errors) ==== -@@= skipped -5, +11 lines =@@ - console.log("foo from a"); - } - --==== b.ts (1 errors) ==== -+==== b.ts (7 errors) ==== - import defer * as aNs from "./a.js"; -- ~~~~~~~~~~~~~~ --!!! error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. -+ ~ -+!!! error TS1005: '=' expected. -+ ~~ -+!!! error TS2304: Cannot find name 'as'. -+ ~~~ -+!!! error TS1005: ';' expected. -+ ~~~ -+!!! error TS2304: Cannot find name 'aNs'. -+ ~~~~ -+!!! error TS1434: Unexpected keyword or identifier. -+ ~~~~ -+!!! error TS2304: Cannot find name 'from'. - - aNs.foo(); -+ ~~~ -+!!! error TS2304: Cannot find name 'aNs'. \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).js b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).js index 7af1257323..29d60657fd 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).js +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).js @@ -15,8 +15,5 @@ export function foo() { console.log("foo from a"); } //// [b.js] - * as; -aNs; -from; -"./a.js"; +import defer * as aNs from "./a.js"; aNs.foo(); diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).js.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).js.diff deleted file mode 100644 index 1ecd218075..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).js.diff +++ /dev/null @@ -1,12 +0,0 @@ ---- old.importDeferNamespace(module=es2015).js -+++ new.importDeferNamespace(module=es2015).js -@@= skipped -14, +14 lines =@@ - console.log("foo from a"); - } - //// [b.js] --import defer * as aNs from "./a.js"; -+ * as; -+aNs; -+from; -+"./a.js"; - aNs.foo(); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).symbols b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).symbols index 2cbec9e857..eca0a04a77 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).symbols +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).symbols @@ -12,6 +12,10 @@ export function foo() { === b.ts === import defer * as aNs from "./a.js"; ->defer : Symbol(defer, Decl(b.ts, 0, 0)) +>aNs : Symbol(aNs, Decl(b.ts, 0, 12)) aNs.foo(); +>aNs.foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) +>aNs : Symbol(aNs, Decl(b.ts, 0, 12)) +>foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) + diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).symbols.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).symbols.diff deleted file mode 100644 index 443be51f7c..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).symbols.diff +++ /dev/null @@ -1,14 +0,0 @@ ---- old.importDeferNamespace(module=es2015).symbols -+++ new.importDeferNamespace(module=es2015).symbols -@@= skipped -11, +11 lines =@@ - - === b.ts === - import defer * as aNs from "./a.js"; -->aNs : Symbol(aNs, Decl(b.ts, 0, 12)) -+>defer : Symbol(defer, Decl(b.ts, 0, 0)) - - aNs.foo(); -->aNs.foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) -->aNs : Symbol(aNs, Decl(b.ts, 0, 12)) -->foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) -- \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).types b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).types index 0222a6c0b7..ea6e0a8783 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).types +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).types @@ -14,18 +14,11 @@ export function foo() { === b.ts === import defer * as aNs from "./a.js"; ->defer : any -> : any ->* as : number -> : any ->as : any ->aNs : any ->from : any ->"./a.js" : "./a.js" +>aNs : typeof aNs aNs.foo(); ->aNs.foo() : any ->aNs.foo : any ->aNs : any ->foo : any +>aNs.foo() : void +>aNs.foo : () => void +>aNs : typeof aNs +>foo : () => void diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).types.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).types.diff deleted file mode 100644 index 01baae6f5e..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2015).types.diff +++ /dev/null @@ -1,25 +0,0 @@ ---- old.importDeferNamespace(module=es2015).types -+++ new.importDeferNamespace(module=es2015).types -@@= skipped -13, +13 lines =@@ - - === b.ts === - import defer * as aNs from "./a.js"; -->aNs : typeof aNs -+>defer : any -+> : any -+>* as : number -+> : any -+>as : any -+>aNs : any -+>from : any -+>"./a.js" : "./a.js" - - aNs.foo(); -->aNs.foo() : void -->aNs.foo : () => void -->aNs : typeof aNs -->foo : () => void -+>aNs.foo() : any -+>aNs.foo : any -+>aNs : any -+>foo : any diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).errors.txt b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).errors.txt index e7c04cb2ea..74c011b13a 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).errors.txt +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).errors.txt @@ -1,10 +1,4 @@ -b.ts(1,14): error TS1005: '=' expected. -b.ts(1,16): error TS2304: Cannot find name 'as'. -b.ts(1,19): error TS1005: ';' expected. -b.ts(1,19): error TS2304: Cannot find name 'aNs'. -b.ts(1,23): error TS1434: Unexpected keyword or identifier. -b.ts(1,23): error TS2304: Cannot find name 'from'. -b.ts(3,1): error TS2304: Cannot find name 'aNs'. +b.ts(1,8): error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. ==== a.ts (0 errors) ==== @@ -12,21 +6,9 @@ b.ts(3,1): error TS2304: Cannot find name 'aNs'. console.log("foo from a"); } -==== b.ts (7 errors) ==== +==== b.ts (1 errors) ==== import defer * as aNs from "./a.js"; - ~ -!!! error TS1005: '=' expected. - ~~ -!!! error TS2304: Cannot find name 'as'. - ~~~ -!!! error TS1005: ';' expected. - ~~~ -!!! error TS2304: Cannot find name 'aNs'. - ~~~~ -!!! error TS1434: Unexpected keyword or identifier. - ~~~~ -!!! error TS2304: Cannot find name 'from'. + ~~~~~~~~~~~~~~ +!!! error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. - aNs.foo(); - ~~~ -!!! error TS2304: Cannot find name 'aNs'. \ No newline at end of file + aNs.foo(); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).errors.txt.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).errors.txt.diff deleted file mode 100644 index 9e243d63de..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).errors.txt.diff +++ /dev/null @@ -1,39 +0,0 @@ ---- old.importDeferNamespace(module=es2020).errors.txt -+++ new.importDeferNamespace(module=es2020).errors.txt -@@= skipped -0, +0 lines =@@ --b.ts(1,8): error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. -+b.ts(1,14): error TS1005: '=' expected. -+b.ts(1,16): error TS2304: Cannot find name 'as'. -+b.ts(1,19): error TS1005: ';' expected. -+b.ts(1,19): error TS2304: Cannot find name 'aNs'. -+b.ts(1,23): error TS1434: Unexpected keyword or identifier. -+b.ts(1,23): error TS2304: Cannot find name 'from'. -+b.ts(3,1): error TS2304: Cannot find name 'aNs'. - - - ==== a.ts (0 errors) ==== -@@= skipped -5, +11 lines =@@ - console.log("foo from a"); - } - --==== b.ts (1 errors) ==== -+==== b.ts (7 errors) ==== - import defer * as aNs from "./a.js"; -- ~~~~~~~~~~~~~~ --!!! error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. -+ ~ -+!!! error TS1005: '=' expected. -+ ~~ -+!!! error TS2304: Cannot find name 'as'. -+ ~~~ -+!!! error TS1005: ';' expected. -+ ~~~ -+!!! error TS2304: Cannot find name 'aNs'. -+ ~~~~ -+!!! error TS1434: Unexpected keyword or identifier. -+ ~~~~ -+!!! error TS2304: Cannot find name 'from'. - - aNs.foo(); -+ ~~~ -+!!! error TS2304: Cannot find name 'aNs'. \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).js b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).js index 7af1257323..29d60657fd 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).js +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).js @@ -15,8 +15,5 @@ export function foo() { console.log("foo from a"); } //// [b.js] - * as; -aNs; -from; -"./a.js"; +import defer * as aNs from "./a.js"; aNs.foo(); diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).js.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).js.diff deleted file mode 100644 index 95908d1e41..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).js.diff +++ /dev/null @@ -1,12 +0,0 @@ ---- old.importDeferNamespace(module=es2020).js -+++ new.importDeferNamespace(module=es2020).js -@@= skipped -14, +14 lines =@@ - console.log("foo from a"); - } - //// [b.js] --import defer * as aNs from "./a.js"; -+ * as; -+aNs; -+from; -+"./a.js"; - aNs.foo(); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).symbols b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).symbols index 2cbec9e857..eca0a04a77 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).symbols +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).symbols @@ -12,6 +12,10 @@ export function foo() { === b.ts === import defer * as aNs from "./a.js"; ->defer : Symbol(defer, Decl(b.ts, 0, 0)) +>aNs : Symbol(aNs, Decl(b.ts, 0, 12)) aNs.foo(); +>aNs.foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) +>aNs : Symbol(aNs, Decl(b.ts, 0, 12)) +>foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) + diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).symbols.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).symbols.diff deleted file mode 100644 index 8266815978..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).symbols.diff +++ /dev/null @@ -1,14 +0,0 @@ ---- old.importDeferNamespace(module=es2020).symbols -+++ new.importDeferNamespace(module=es2020).symbols -@@= skipped -11, +11 lines =@@ - - === b.ts === - import defer * as aNs from "./a.js"; -->aNs : Symbol(aNs, Decl(b.ts, 0, 12)) -+>defer : Symbol(defer, Decl(b.ts, 0, 0)) - - aNs.foo(); -->aNs.foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) -->aNs : Symbol(aNs, Decl(b.ts, 0, 12)) -->foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) -- \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).types b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).types index 0222a6c0b7..ea6e0a8783 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).types +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).types @@ -14,18 +14,11 @@ export function foo() { === b.ts === import defer * as aNs from "./a.js"; ->defer : any -> : any ->* as : number -> : any ->as : any ->aNs : any ->from : any ->"./a.js" : "./a.js" +>aNs : typeof aNs aNs.foo(); ->aNs.foo() : any ->aNs.foo : any ->aNs : any ->foo : any +>aNs.foo() : void +>aNs.foo : () => void +>aNs : typeof aNs +>foo : () => void diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).types.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).types.diff deleted file mode 100644 index 0f72fbf8c9..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=es2020).types.diff +++ /dev/null @@ -1,25 +0,0 @@ ---- old.importDeferNamespace(module=es2020).types -+++ new.importDeferNamespace(module=es2020).types -@@= skipped -13, +13 lines =@@ - - === b.ts === - import defer * as aNs from "./a.js"; -->aNs : typeof aNs -+>defer : any -+> : any -+>* as : number -+> : any -+>as : any -+>aNs : any -+>from : any -+>"./a.js" : "./a.js" - - aNs.foo(); -->aNs.foo() : void -->aNs.foo : () => void -->aNs : typeof aNs -->foo : () => void -+>aNs.foo() : any -+>aNs.foo : any -+>aNs : any -+>foo : any diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).errors.txt b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).errors.txt deleted file mode 100644 index e7c04cb2ea..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).errors.txt +++ /dev/null @@ -1,32 +0,0 @@ -b.ts(1,14): error TS1005: '=' expected. -b.ts(1,16): error TS2304: Cannot find name 'as'. -b.ts(1,19): error TS1005: ';' expected. -b.ts(1,19): error TS2304: Cannot find name 'aNs'. -b.ts(1,23): error TS1434: Unexpected keyword or identifier. -b.ts(1,23): error TS2304: Cannot find name 'from'. -b.ts(3,1): error TS2304: Cannot find name 'aNs'. - - -==== a.ts (0 errors) ==== - export function foo() { - console.log("foo from a"); - } - -==== b.ts (7 errors) ==== - import defer * as aNs from "./a.js"; - ~ -!!! error TS1005: '=' expected. - ~~ -!!! error TS2304: Cannot find name 'as'. - ~~~ -!!! error TS1005: ';' expected. - ~~~ -!!! error TS2304: Cannot find name 'aNs'. - ~~~~ -!!! error TS1434: Unexpected keyword or identifier. - ~~~~ -!!! error TS2304: Cannot find name 'from'. - - aNs.foo(); - ~~~ -!!! error TS2304: Cannot find name 'aNs'. \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).errors.txt.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).errors.txt.diff deleted file mode 100644 index 449519efed..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).errors.txt.diff +++ /dev/null @@ -1,36 +0,0 @@ ---- old.importDeferNamespace(module=esnext).errors.txt -+++ new.importDeferNamespace(module=esnext).errors.txt -@@= skipped -0, +0 lines =@@ -- -+b.ts(1,14): error TS1005: '=' expected. -+b.ts(1,16): error TS2304: Cannot find name 'as'. -+b.ts(1,19): error TS1005: ';' expected. -+b.ts(1,19): error TS2304: Cannot find name 'aNs'. -+b.ts(1,23): error TS1434: Unexpected keyword or identifier. -+b.ts(1,23): error TS2304: Cannot find name 'from'. -+b.ts(3,1): error TS2304: Cannot find name 'aNs'. -+ -+ -+==== a.ts (0 errors) ==== -+ export function foo() { -+ console.log("foo from a"); -+ } -+ -+==== b.ts (7 errors) ==== -+ import defer * as aNs from "./a.js"; -+ ~ -+!!! error TS1005: '=' expected. -+ ~~ -+!!! error TS2304: Cannot find name 'as'. -+ ~~~ -+!!! error TS1005: ';' expected. -+ ~~~ -+!!! error TS2304: Cannot find name 'aNs'. -+ ~~~~ -+!!! error TS1434: Unexpected keyword or identifier. -+ ~~~~ -+!!! error TS2304: Cannot find name 'from'. -+ -+ aNs.foo(); -+ ~~~ -+!!! error TS2304: Cannot find name 'aNs'. \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).js b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).js index 7af1257323..29d60657fd 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).js +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).js @@ -15,8 +15,5 @@ export function foo() { console.log("foo from a"); } //// [b.js] - * as; -aNs; -from; -"./a.js"; +import defer * as aNs from "./a.js"; aNs.foo(); diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).js.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).js.diff deleted file mode 100644 index 972ced87e4..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).js.diff +++ /dev/null @@ -1,12 +0,0 @@ ---- old.importDeferNamespace(module=esnext).js -+++ new.importDeferNamespace(module=esnext).js -@@= skipped -14, +14 lines =@@ - console.log("foo from a"); - } - //// [b.js] --import defer * as aNs from "./a.js"; -+ * as; -+aNs; -+from; -+"./a.js"; - aNs.foo(); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).symbols b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).symbols index 2cbec9e857..eca0a04a77 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).symbols +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).symbols @@ -12,6 +12,10 @@ export function foo() { === b.ts === import defer * as aNs from "./a.js"; ->defer : Symbol(defer, Decl(b.ts, 0, 0)) +>aNs : Symbol(aNs, Decl(b.ts, 0, 12)) aNs.foo(); +>aNs.foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) +>aNs : Symbol(aNs, Decl(b.ts, 0, 12)) +>foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) + diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).symbols.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).symbols.diff deleted file mode 100644 index 9cd4a2287f..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).symbols.diff +++ /dev/null @@ -1,14 +0,0 @@ ---- old.importDeferNamespace(module=esnext).symbols -+++ new.importDeferNamespace(module=esnext).symbols -@@= skipped -11, +11 lines =@@ - - === b.ts === - import defer * as aNs from "./a.js"; -->aNs : Symbol(aNs, Decl(b.ts, 0, 12)) -+>defer : Symbol(defer, Decl(b.ts, 0, 0)) - - aNs.foo(); -->aNs.foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) -->aNs : Symbol(aNs, Decl(b.ts, 0, 12)) -->foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) -- \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).types b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).types index 0222a6c0b7..ea6e0a8783 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).types +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).types @@ -14,18 +14,11 @@ export function foo() { === b.ts === import defer * as aNs from "./a.js"; ->defer : any -> : any ->* as : number -> : any ->as : any ->aNs : any ->from : any ->"./a.js" : "./a.js" +>aNs : typeof aNs aNs.foo(); ->aNs.foo() : any ->aNs.foo : any ->aNs : any ->foo : any +>aNs.foo() : void +>aNs.foo : () => void +>aNs : typeof aNs +>foo : () => void diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).types.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).types.diff deleted file mode 100644 index 0144add4ff..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=esnext).types.diff +++ /dev/null @@ -1,25 +0,0 @@ ---- old.importDeferNamespace(module=esnext).types -+++ new.importDeferNamespace(module=esnext).types -@@= skipped -13, +13 lines =@@ - - === b.ts === - import defer * as aNs from "./a.js"; -->aNs : typeof aNs -+>defer : any -+> : any -+>* as : number -+> : any -+>as : any -+>aNs : any -+>from : any -+>"./a.js" : "./a.js" - - aNs.foo(); -->aNs.foo() : void -->aNs.foo : () => void -->aNs : typeof aNs -->foo : () => void -+>aNs.foo() : any -+>aNs.foo : any -+>aNs : any -+>foo : any diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).errors.txt b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).errors.txt index e7c04cb2ea..74c011b13a 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).errors.txt +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).errors.txt @@ -1,10 +1,4 @@ -b.ts(1,14): error TS1005: '=' expected. -b.ts(1,16): error TS2304: Cannot find name 'as'. -b.ts(1,19): error TS1005: ';' expected. -b.ts(1,19): error TS2304: Cannot find name 'aNs'. -b.ts(1,23): error TS1434: Unexpected keyword or identifier. -b.ts(1,23): error TS2304: Cannot find name 'from'. -b.ts(3,1): error TS2304: Cannot find name 'aNs'. +b.ts(1,8): error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. ==== a.ts (0 errors) ==== @@ -12,21 +6,9 @@ b.ts(3,1): error TS2304: Cannot find name 'aNs'. console.log("foo from a"); } -==== b.ts (7 errors) ==== +==== b.ts (1 errors) ==== import defer * as aNs from "./a.js"; - ~ -!!! error TS1005: '=' expected. - ~~ -!!! error TS2304: Cannot find name 'as'. - ~~~ -!!! error TS1005: ';' expected. - ~~~ -!!! error TS2304: Cannot find name 'aNs'. - ~~~~ -!!! error TS1434: Unexpected keyword or identifier. - ~~~~ -!!! error TS2304: Cannot find name 'from'. + ~~~~~~~~~~~~~~ +!!! error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. - aNs.foo(); - ~~~ -!!! error TS2304: Cannot find name 'aNs'. \ No newline at end of file + aNs.foo(); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).errors.txt.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).errors.txt.diff deleted file mode 100644 index 3d0318c3ae..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).errors.txt.diff +++ /dev/null @@ -1,39 +0,0 @@ ---- old.importDeferNamespace(module=nodenext).errors.txt -+++ new.importDeferNamespace(module=nodenext).errors.txt -@@= skipped -0, +0 lines =@@ --b.ts(1,8): error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. -+b.ts(1,14): error TS1005: '=' expected. -+b.ts(1,16): error TS2304: Cannot find name 'as'. -+b.ts(1,19): error TS1005: ';' expected. -+b.ts(1,19): error TS2304: Cannot find name 'aNs'. -+b.ts(1,23): error TS1434: Unexpected keyword or identifier. -+b.ts(1,23): error TS2304: Cannot find name 'from'. -+b.ts(3,1): error TS2304: Cannot find name 'aNs'. - - - ==== a.ts (0 errors) ==== -@@= skipped -5, +11 lines =@@ - console.log("foo from a"); - } - --==== b.ts (1 errors) ==== -+==== b.ts (7 errors) ==== - import defer * as aNs from "./a.js"; -- ~~~~~~~~~~~~~~ --!!! error TS18060: Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'. -+ ~ -+!!! error TS1005: '=' expected. -+ ~~ -+!!! error TS2304: Cannot find name 'as'. -+ ~~~ -+!!! error TS1005: ';' expected. -+ ~~~ -+!!! error TS2304: Cannot find name 'aNs'. -+ ~~~~ -+!!! error TS1434: Unexpected keyword or identifier. -+ ~~~~ -+!!! error TS2304: Cannot find name 'from'. - - aNs.foo(); -+ ~~~ -+!!! error TS2304: Cannot find name 'aNs'. \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).js b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).js index 78265562c9..95cd4ac60d 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).js +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).js @@ -19,9 +19,39 @@ function foo() { } //// [b.js] "use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); - * as; -aNs; -from; -"./a.js"; +const aNs = __importStar(require("./a.js")); aNs.foo(); diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).js.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).js.diff deleted file mode 100644 index 624e566704..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).js.diff +++ /dev/null @@ -1,46 +0,0 @@ ---- old.importDeferNamespace(module=nodenext).js -+++ new.importDeferNamespace(module=nodenext).js -@@= skipped -18, +18 lines =@@ - } - //// [b.js] - "use strict"; --var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { -- if (k2 === undefined) k2 = k; -- var desc = Object.getOwnPropertyDescriptor(m, k); -- if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { -- desc = { enumerable: true, get: function() { return m[k]; } }; -- } -- Object.defineProperty(o, k2, desc); --}) : (function(o, m, k, k2) { -- if (k2 === undefined) k2 = k; -- o[k2] = m[k]; --})); --var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { -- Object.defineProperty(o, "default", { enumerable: true, value: v }); --}) : function(o, v) { -- o["default"] = v; --}); --var __importStar = (this && this.__importStar) || (function () { -- var ownKeys = function(o) { -- ownKeys = Object.getOwnPropertyNames || function (o) { -- var ar = []; -- for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; -- return ar; -- }; -- return ownKeys(o); -- }; -- return function (mod) { -- if (mod && mod.__esModule) return mod; -- var result = {}; -- if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); -- __setModuleDefault(result, mod); -- return result; -- }; --})(); - Object.defineProperty(exports, "__esModule", { value: true }); --const aNs = __importStar(require("./a.js")); -+ * as; -+aNs; -+from; -+"./a.js"; - aNs.foo(); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).symbols b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).symbols index 2cbec9e857..eca0a04a77 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).symbols +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).symbols @@ -12,6 +12,10 @@ export function foo() { === b.ts === import defer * as aNs from "./a.js"; ->defer : Symbol(defer, Decl(b.ts, 0, 0)) +>aNs : Symbol(aNs, Decl(b.ts, 0, 12)) aNs.foo(); +>aNs.foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) +>aNs : Symbol(aNs, Decl(b.ts, 0, 12)) +>foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) + diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).symbols.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).symbols.diff deleted file mode 100644 index 5ff422bbd3..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).symbols.diff +++ /dev/null @@ -1,14 +0,0 @@ ---- old.importDeferNamespace(module=nodenext).symbols -+++ new.importDeferNamespace(module=nodenext).symbols -@@= skipped -11, +11 lines =@@ - - === b.ts === - import defer * as aNs from "./a.js"; -->aNs : Symbol(aNs, Decl(b.ts, 0, 12)) -+>defer : Symbol(defer, Decl(b.ts, 0, 0)) - - aNs.foo(); -->aNs.foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) -->aNs : Symbol(aNs, Decl(b.ts, 0, 12)) -->foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) -- \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).types b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).types index 0222a6c0b7..ea6e0a8783 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).types +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).types @@ -14,18 +14,11 @@ export function foo() { === b.ts === import defer * as aNs from "./a.js"; ->defer : any -> : any ->* as : number -> : any ->as : any ->aNs : any ->from : any ->"./a.js" : "./a.js" +>aNs : typeof aNs aNs.foo(); ->aNs.foo() : any ->aNs.foo : any ->aNs : any ->foo : any +>aNs.foo() : void +>aNs.foo : () => void +>aNs : typeof aNs +>foo : () => void diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).types.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).types.diff deleted file mode 100644 index d4fd725371..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=nodenext).types.diff +++ /dev/null @@ -1,25 +0,0 @@ ---- old.importDeferNamespace(module=nodenext).types -+++ new.importDeferNamespace(module=nodenext).types -@@= skipped -13, +13 lines =@@ - - === b.ts === - import defer * as aNs from "./a.js"; -->aNs : typeof aNs -+>defer : any -+> : any -+>* as : number -+> : any -+>as : any -+>aNs : any -+>from : any -+>"./a.js" : "./a.js" - - aNs.foo(); -->aNs.foo() : void -->aNs.foo : () => void -->aNs : typeof aNs -->foo : () => void -+>aNs.foo() : any -+>aNs.foo : any -+>aNs : any -+>foo : any diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).errors.txt b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).errors.txt deleted file mode 100644 index e7c04cb2ea..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).errors.txt +++ /dev/null @@ -1,32 +0,0 @@ -b.ts(1,14): error TS1005: '=' expected. -b.ts(1,16): error TS2304: Cannot find name 'as'. -b.ts(1,19): error TS1005: ';' expected. -b.ts(1,19): error TS2304: Cannot find name 'aNs'. -b.ts(1,23): error TS1434: Unexpected keyword or identifier. -b.ts(1,23): error TS2304: Cannot find name 'from'. -b.ts(3,1): error TS2304: Cannot find name 'aNs'. - - -==== a.ts (0 errors) ==== - export function foo() { - console.log("foo from a"); - } - -==== b.ts (7 errors) ==== - import defer * as aNs from "./a.js"; - ~ -!!! error TS1005: '=' expected. - ~~ -!!! error TS2304: Cannot find name 'as'. - ~~~ -!!! error TS1005: ';' expected. - ~~~ -!!! error TS2304: Cannot find name 'aNs'. - ~~~~ -!!! error TS1434: Unexpected keyword or identifier. - ~~~~ -!!! error TS2304: Cannot find name 'from'. - - aNs.foo(); - ~~~ -!!! error TS2304: Cannot find name 'aNs'. \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).errors.txt.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).errors.txt.diff deleted file mode 100644 index 6b68da8b87..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).errors.txt.diff +++ /dev/null @@ -1,36 +0,0 @@ ---- old.importDeferNamespace(module=preserve).errors.txt -+++ new.importDeferNamespace(module=preserve).errors.txt -@@= skipped -0, +0 lines =@@ -- -+b.ts(1,14): error TS1005: '=' expected. -+b.ts(1,16): error TS2304: Cannot find name 'as'. -+b.ts(1,19): error TS1005: ';' expected. -+b.ts(1,19): error TS2304: Cannot find name 'aNs'. -+b.ts(1,23): error TS1434: Unexpected keyword or identifier. -+b.ts(1,23): error TS2304: Cannot find name 'from'. -+b.ts(3,1): error TS2304: Cannot find name 'aNs'. -+ -+ -+==== a.ts (0 errors) ==== -+ export function foo() { -+ console.log("foo from a"); -+ } -+ -+==== b.ts (7 errors) ==== -+ import defer * as aNs from "./a.js"; -+ ~ -+!!! error TS1005: '=' expected. -+ ~~ -+!!! error TS2304: Cannot find name 'as'. -+ ~~~ -+!!! error TS1005: ';' expected. -+ ~~~ -+!!! error TS2304: Cannot find name 'aNs'. -+ ~~~~ -+!!! error TS1434: Unexpected keyword or identifier. -+ ~~~~ -+!!! error TS2304: Cannot find name 'from'. -+ -+ aNs.foo(); -+ ~~~ -+!!! error TS2304: Cannot find name 'aNs'. \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).js b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).js index 7af1257323..29d60657fd 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).js +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).js @@ -15,8 +15,5 @@ export function foo() { console.log("foo from a"); } //// [b.js] - * as; -aNs; -from; -"./a.js"; +import defer * as aNs from "./a.js"; aNs.foo(); diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).js.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).js.diff deleted file mode 100644 index 23c2597f5d..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).js.diff +++ /dev/null @@ -1,12 +0,0 @@ ---- old.importDeferNamespace(module=preserve).js -+++ new.importDeferNamespace(module=preserve).js -@@= skipped -14, +14 lines =@@ - console.log("foo from a"); - } - //// [b.js] --import defer * as aNs from "./a.js"; -+ * as; -+aNs; -+from; -+"./a.js"; - aNs.foo(); \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).symbols b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).symbols index 2cbec9e857..eca0a04a77 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).symbols +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).symbols @@ -12,6 +12,10 @@ export function foo() { === b.ts === import defer * as aNs from "./a.js"; ->defer : Symbol(defer, Decl(b.ts, 0, 0)) +>aNs : Symbol(aNs, Decl(b.ts, 0, 12)) aNs.foo(); +>aNs.foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) +>aNs : Symbol(aNs, Decl(b.ts, 0, 12)) +>foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) + diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).symbols.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).symbols.diff deleted file mode 100644 index 7acf641179..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).symbols.diff +++ /dev/null @@ -1,14 +0,0 @@ ---- old.importDeferNamespace(module=preserve).symbols -+++ new.importDeferNamespace(module=preserve).symbols -@@= skipped -11, +11 lines =@@ - - === b.ts === - import defer * as aNs from "./a.js"; -->aNs : Symbol(aNs, Decl(b.ts, 0, 12)) -+>defer : Symbol(defer, Decl(b.ts, 0, 0)) - - aNs.foo(); -->aNs.foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) -->aNs : Symbol(aNs, Decl(b.ts, 0, 12)) -->foo : Symbol(aNs.foo, Decl(a.ts, 0, 0)) -- \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).types b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).types index 0222a6c0b7..ea6e0a8783 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).types +++ b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).types @@ -14,18 +14,11 @@ export function foo() { === b.ts === import defer * as aNs from "./a.js"; ->defer : any -> : any ->* as : number -> : any ->as : any ->aNs : any ->from : any ->"./a.js" : "./a.js" +>aNs : typeof aNs aNs.foo(); ->aNs.foo() : any ->aNs.foo : any ->aNs : any ->foo : any +>aNs.foo() : void +>aNs.foo : () => void +>aNs : typeof aNs +>foo : () => void diff --git a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).types.diff b/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).types.diff deleted file mode 100644 index abca7ace49..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferNamespace(module=preserve).types.diff +++ /dev/null @@ -1,25 +0,0 @@ ---- old.importDeferNamespace(module=preserve).types -+++ new.importDeferNamespace(module=preserve).types -@@= skipped -13, +13 lines =@@ - - === b.ts === - import defer * as aNs from "./a.js"; -->aNs : typeof aNs -+>defer : any -+> : any -+>* as : number -+> : any -+>as : any -+>aNs : any -+>from : any -+>"./a.js" : "./a.js" - - aNs.foo(); -->aNs.foo() : void -->aNs.foo : () => void -->aNs : typeof aNs -->foo : () => void -+>aNs.foo() : any -+>aNs.foo : any -+>aNs : any -+>foo : any diff --git a/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.errors.txt b/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.errors.txt index f53672cf84..2387d3e34a 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.errors.txt +++ b/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.errors.txt @@ -1,7 +1,5 @@ -b.ts(1,14): error TS1005: '=' expected. -b.ts(1,14): error TS2503: Cannot find namespace 'type'. -b.ts(1,19): error TS1005: ';' expected. -b.ts(1,21): error TS2304: Cannot find name 'as'. +b.ts(1,19): error TS1005: 'from' expected. +b.ts(1,19): error TS1141: String literal expected. b.ts(1,24): error TS1005: ';' expected. b.ts(1,24): error TS2304: Cannot find name 'ns1'. b.ts(1,28): error TS1434: Unexpected keyword or identifier. @@ -13,16 +11,12 @@ b.ts(1,28): error TS2304: Cannot find name 'from'. console.log("foo from a"); } -==== b.ts (8 errors) ==== +==== b.ts (6 errors) ==== import defer type * as ns1 from "a"; - ~~~~ -!!! error TS1005: '=' expected. - ~~~~ -!!! error TS2503: Cannot find namespace 'type'. ~ -!!! error TS1005: ';' expected. - ~~ -!!! error TS2304: Cannot find name 'as'. +!!! error TS1005: 'from' expected. + ~~~~ +!!! error TS1141: String literal expected. ~~~ !!! error TS1005: ';' expected. ~~~ diff --git a/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.errors.txt.diff b/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.errors.txt.diff deleted file mode 100644 index a904c142a6..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.errors.txt.diff +++ /dev/null @@ -1,33 +0,0 @@ ---- old.importDeferTypeConflict2.errors.txt -+++ new.importDeferTypeConflict2.errors.txt -@@= skipped -0, +0 lines =@@ --b.ts(1,19): error TS1005: 'from' expected. --b.ts(1,19): error TS1141: String literal expected. -+b.ts(1,14): error TS1005: '=' expected. -+b.ts(1,14): error TS2503: Cannot find namespace 'type'. -+b.ts(1,19): error TS1005: ';' expected. -+b.ts(1,21): error TS2304: Cannot find name 'as'. - b.ts(1,24): error TS1005: ';' expected. - b.ts(1,24): error TS2304: Cannot find name 'ns1'. - b.ts(1,28): error TS1434: Unexpected keyword or identifier. -@@= skipped -10, +12 lines =@@ - console.log("foo from a"); - } - --==== b.ts (6 errors) ==== -+==== b.ts (8 errors) ==== - import defer type * as ns1 from "a"; -+ ~~~~ -+!!! error TS1005: '=' expected. -+ ~~~~ -+!!! error TS2503: Cannot find namespace 'type'. - ~ --!!! error TS1005: 'from' expected. -- ~~~~ --!!! error TS1141: String literal expected. -+!!! error TS1005: ';' expected. -+ ~~ -+!!! error TS2304: Cannot find name 'as'. - ~~~ - !!! error TS1005: ';' expected. - ~~~ \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.js b/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.js index e9b6d90e8f..1c06d70469 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.js +++ b/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.js @@ -14,7 +14,7 @@ export function foo() { console.log("foo from a"); } //// [b.js] - * as; ns1; from; "a"; +export {}; diff --git a/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.js.diff b/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.js.diff deleted file mode 100644 index 3085bf87d1..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.js.diff +++ /dev/null @@ -1,11 +0,0 @@ ---- old.importDeferTypeConflict2.js -+++ new.importDeferTypeConflict2.js -@@= skipped -13, +13 lines =@@ - console.log("foo from a"); - } - //// [b.js] -+ * as; - ns1; - from; - "a"; --export {}; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.symbols b/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.symbols index 8378d25d21..ea867e3cfd 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.symbols +++ b/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.symbols @@ -12,5 +12,5 @@ export function foo() { === b.ts === import defer type * as ns1 from "a"; ->defer : Symbol(defer, Decl(b.ts, 0, 0)) +>type : Symbol(type, Decl(b.ts, 0, 6)) diff --git a/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.symbols.diff b/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.symbols.diff deleted file mode 100644 index 4c2d75c2a8..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.symbols.diff +++ /dev/null @@ -1,8 +0,0 @@ ---- old.importDeferTypeConflict2.symbols -+++ new.importDeferTypeConflict2.symbols -@@= skipped -11, +11 lines =@@ - - === b.ts === - import defer type * as ns1 from "a"; -->type : Symbol(type, Decl(b.ts, 0, 6)) -+>defer : Symbol(defer, Decl(b.ts, 0, 0)) diff --git a/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.types b/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.types index 94413ecd00..5c106b971d 100644 --- a/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.types +++ b/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.types @@ -14,7 +14,6 @@ export function foo() { === b.ts === import defer type * as ns1 from "a"; ->defer : any >type : any >* as : number > : any diff --git a/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.types.diff b/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.types.diff deleted file mode 100644 index c8ff22b7ed..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importDeferTypeConflict2.types.diff +++ /dev/null @@ -1,10 +0,0 @@ ---- old.importDeferTypeConflict2.types -+++ new.importDeferTypeConflict2.types -@@= skipped -13, +13 lines =@@ - - === b.ts === - import defer type * as ns1 from "a"; -+>defer : any - >type : any - >* as : number - > : any \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/importMetaPropertyInvalidInCall.errors.txt b/testdata/baselines/reference/submodule/conformance/importMetaPropertyInvalidInCall.errors.txt index bffc65bd50..6ab3da5017 100644 --- a/testdata/baselines/reference/submodule/conformance/importMetaPropertyInvalidInCall.errors.txt +++ b/testdata/baselines/reference/submodule/conformance/importMetaPropertyInvalidInCall.errors.txt @@ -1,11 +1,11 @@ -b.ts(1,8): error TS17012: 'foo' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? +b.ts(1,8): error TS18061: 'foo' is not a valid meta-property for keyword 'import'. Did you mean 'meta' or 'defer'? b.ts(2,8): error TS17012: 'foo' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? ==== b.ts (2 errors) ==== import.foo(); ~~~ -!!! error TS17012: 'foo' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? +!!! error TS18061: 'foo' is not a valid meta-property for keyword 'import'. Did you mean 'meta' or 'defer'? import.foo; ~~~ !!! error TS17012: 'foo' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? diff --git a/testdata/baselines/reference/submodule/conformance/importMetaPropertyInvalidInCall.errors.txt.diff b/testdata/baselines/reference/submodule/conformance/importMetaPropertyInvalidInCall.errors.txt.diff deleted file mode 100644 index 90d35231eb..0000000000 --- a/testdata/baselines/reference/submodule/conformance/importMetaPropertyInvalidInCall.errors.txt.diff +++ /dev/null @@ -1,16 +0,0 @@ ---- old.importMetaPropertyInvalidInCall.errors.txt -+++ new.importMetaPropertyInvalidInCall.errors.txt -@@= skipped -0, +0 lines =@@ --b.ts(1,8): error TS18061: 'foo' is not a valid meta-property for keyword 'import'. Did you mean 'meta' or 'defer'? -+b.ts(1,8): error TS17012: 'foo' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - b.ts(2,8): error TS17012: 'foo' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - - - ==== b.ts (2 errors) ==== - import.foo(); - ~~~ --!!! error TS18061: 'foo' is not a valid meta-property for keyword 'import'. Did you mean 'meta' or 'defer'? -+!!! error TS17012: 'foo' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? - import.foo; - ~~~ - !!! error TS17012: 'foo' is not a valid meta-property for keyword 'import'. Did you mean 'meta'? \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/mixinAccessors1.errors.txt b/testdata/baselines/reference/submodule/conformance/mixinAccessors1.errors.txt deleted file mode 100644 index 4c13cf3c6b..0000000000 --- a/testdata/baselines/reference/submodule/conformance/mixinAccessors1.errors.txt +++ /dev/null @@ -1,27 +0,0 @@ -mixinAccessors1.ts(18,7): error TS2611: 'validationTarget' is defined as a property in class 'mixin.(Anonymous class) & BaseClass', but is overridden here in 'MyClass' as an accessor. - - -==== mixinAccessors1.ts (1 errors) ==== - // https://github.com/microsoft/TypeScript/issues/58790 - - function mixin(superclass: T) { - return class extends superclass { - get validationTarget(): HTMLElement { - return document.createElement("input"); - } - }; - } - - class BaseClass { - get validationTarget(): HTMLElement { - return document.createElement("div"); - } - } - - class MyClass extends mixin(BaseClass) { - get validationTarget(): HTMLElement { - ~~~~~~~~~~~~~~~~ -!!! error TS2611: 'validationTarget' is defined as a property in class 'mixin.(Anonymous class) & BaseClass', but is overridden here in 'MyClass' as an accessor. - return document.createElement("select"); - } - } \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/mixinAccessors1.errors.txt.diff b/testdata/baselines/reference/submodule/conformance/mixinAccessors1.errors.txt.diff deleted file mode 100644 index 1dada5111f..0000000000 --- a/testdata/baselines/reference/submodule/conformance/mixinAccessors1.errors.txt.diff +++ /dev/null @@ -1,31 +0,0 @@ ---- old.mixinAccessors1.errors.txt -+++ new.mixinAccessors1.errors.txt -@@= skipped -0, +0 lines =@@ -- -+mixinAccessors1.ts(18,7): error TS2611: 'validationTarget' is defined as a property in class 'mixin.(Anonymous class) & BaseClass', but is overridden here in 'MyClass' as an accessor. -+ -+ -+==== mixinAccessors1.ts (1 errors) ==== -+ // https://github.com/microsoft/TypeScript/issues/58790 -+ -+ function mixin(superclass: T) { -+ return class extends superclass { -+ get validationTarget(): HTMLElement { -+ return document.createElement("input"); -+ } -+ }; -+ } -+ -+ class BaseClass { -+ get validationTarget(): HTMLElement { -+ return document.createElement("div"); -+ } -+ } -+ -+ class MyClass extends mixin(BaseClass) { -+ get validationTarget(): HTMLElement { -+ ~~~~~~~~~~~~~~~~ -+!!! error TS2611: 'validationTarget' is defined as a property in class 'mixin.(Anonymous class) & BaseClass', but is overridden here in 'MyClass' as an accessor. -+ return document.createElement("select"); -+ } -+ } \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/mixinAccessors1.js b/testdata/baselines/reference/submodule/conformance/mixinAccessors1.js index a79d463fcd..9d17437369 100644 --- a/testdata/baselines/reference/submodule/conformance/mixinAccessors1.js +++ b/testdata/baselines/reference/submodule/conformance/mixinAccessors1.js @@ -49,7 +49,7 @@ declare function mixin(superclass: T): { new (...args: any[]): { - readonly validationTarget: HTMLElement; + get validationTarget(): HTMLElement; }; } & T; declare class BaseClass { @@ -57,7 +57,7 @@ declare class BaseClass { } declare const MyClass_base: { new (...args: any[]): { - readonly validationTarget: HTMLElement; + get validationTarget(): HTMLElement; }; } & typeof BaseClass; declare class MyClass extends MyClass_base { diff --git a/testdata/baselines/reference/submodule/conformance/mixinAccessors1.js.diff b/testdata/baselines/reference/submodule/conformance/mixinAccessors1.js.diff index 625e0b6e88..da7fd0def3 100644 --- a/testdata/baselines/reference/submodule/conformance/mixinAccessors1.js.diff +++ b/testdata/baselines/reference/submodule/conformance/mixinAccessors1.js.diff @@ -7,22 +7,4 @@ -"use strict"; // https://github.com/microsoft/TypeScript/issues/58790 function mixin(superclass) { - return class extends superclass { -@@= skipped -26, +25 lines =@@ - new (...args: any[]): {}; - }>(superclass: T): { - new (...args: any[]): { -- get validationTarget(): HTMLElement; -+ readonly validationTarget: HTMLElement; - }; - } & T; - declare class BaseClass { -@@= skipped -8, +8 lines =@@ - } - declare const MyClass_base: { - new (...args: any[]): { -- get validationTarget(): HTMLElement; -+ readonly validationTarget: HTMLElement; - }; - } & typeof BaseClass; - declare class MyClass extends MyClass_base { \ No newline at end of file + return class extends superclass { \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/mixinAccessors2.errors.txt b/testdata/baselines/reference/submodule/conformance/mixinAccessors2.errors.txt deleted file mode 100644 index 57b9d71d86..0000000000 --- a/testdata/baselines/reference/submodule/conformance/mixinAccessors2.errors.txt +++ /dev/null @@ -1,20 +0,0 @@ -mixinAccessors2.ts(12,12): error TS2611: 'name' is defined as a property in class 'mixin.(Anonymous class) & BaseClass', but is overridden here in 'MyClass' as an accessor. - - -==== mixinAccessors2.ts (1 errors) ==== - function mixin(superclass: T) { - return class extends superclass { - accessor name = ""; - }; - } - - class BaseClass { - accessor name = ""; - } - - class MyClass extends mixin(BaseClass) { - accessor name = ""; - ~~~~ -!!! error TS2611: 'name' is defined as a property in class 'mixin.(Anonymous class) & BaseClass', but is overridden here in 'MyClass' as an accessor. - } - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/mixinAccessors2.errors.txt.diff b/testdata/baselines/reference/submodule/conformance/mixinAccessors2.errors.txt.diff deleted file mode 100644 index 9caf5d592b..0000000000 --- a/testdata/baselines/reference/submodule/conformance/mixinAccessors2.errors.txt.diff +++ /dev/null @@ -1,24 +0,0 @@ ---- old.mixinAccessors2.errors.txt -+++ new.mixinAccessors2.errors.txt -@@= skipped -0, +0 lines =@@ -- -+mixinAccessors2.ts(12,12): error TS2611: 'name' is defined as a property in class 'mixin.(Anonymous class) & BaseClass', but is overridden here in 'MyClass' as an accessor. -+ -+ -+==== mixinAccessors2.ts (1 errors) ==== -+ function mixin(superclass: T) { -+ return class extends superclass { -+ accessor name = ""; -+ }; -+ } -+ -+ class BaseClass { -+ accessor name = ""; -+ } -+ -+ class MyClass extends mixin(BaseClass) { -+ accessor name = ""; -+ ~~~~ -+!!! error TS2611: 'name' is defined as a property in class 'mixin.(Anonymous class) & BaseClass', but is overridden here in 'MyClass' as an accessor. -+ } -+ \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/mixinAccessors2.js b/testdata/baselines/reference/submodule/conformance/mixinAccessors2.js index 9a91ff2634..6d768eb164 100644 --- a/testdata/baselines/reference/submodule/conformance/mixinAccessors2.js +++ b/testdata/baselines/reference/submodule/conformance/mixinAccessors2.js @@ -35,7 +35,8 @@ declare function mixin(superclass: T): { new (...args: any[]): { - name: string; + get name(): string; + set name(arg: string); }; } & T; declare class BaseClass { @@ -43,7 +44,8 @@ declare class BaseClass { } declare const MyClass_base: { new (...args: any[]): { - name: string; + get name(): string; + set name(arg: string); }; } & typeof BaseClass; declare class MyClass extends MyClass_base { diff --git a/testdata/baselines/reference/submodule/conformance/mixinAccessors2.js.diff b/testdata/baselines/reference/submodule/conformance/mixinAccessors2.js.diff index e344750daf..305c3b5dbb 100644 --- a/testdata/baselines/reference/submodule/conformance/mixinAccessors2.js.diff +++ b/testdata/baselines/reference/submodule/conformance/mixinAccessors2.js.diff @@ -7,24 +7,4 @@ -"use strict"; function mixin(superclass) { return class extends superclass { - accessor name = ""; -@@= skipped -19, +18 lines =@@ - new (...args: any[]): {}; - }>(superclass: T): { - new (...args: any[]): { -- get name(): string; -- set name(arg: string); -+ name: string; - }; - } & T; - declare class BaseClass { -@@= skipped -9, +8 lines =@@ - } - declare const MyClass_base: { - new (...args: any[]): { -- get name(): string; -- set name(arg: string); -+ name: string; - }; - } & typeof BaseClass; - declare class MyClass extends MyClass_base { \ No newline at end of file + accessor name = ""; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/mixinAccessors3.js b/testdata/baselines/reference/submodule/conformance/mixinAccessors3.js index 288505cd09..21ee8151ce 100644 --- a/testdata/baselines/reference/submodule/conformance/mixinAccessors3.js +++ b/testdata/baselines/reference/submodule/conformance/mixinAccessors3.js @@ -45,7 +45,7 @@ declare function mixin(superclass: T): { new (...args: any[]): { - readonly name: string; + get name(): string; }; } & T; declare class BaseClass { @@ -53,7 +53,7 @@ declare class BaseClass { } declare const MyClass_base: { new (...args: any[]): { - readonly name: string; + get name(): string; }; } & typeof BaseClass; declare class MyClass extends MyClass_base { diff --git a/testdata/baselines/reference/submodule/conformance/mixinAccessors3.js.diff b/testdata/baselines/reference/submodule/conformance/mixinAccessors3.js.diff index 40189dff2d..359905d983 100644 --- a/testdata/baselines/reference/submodule/conformance/mixinAccessors3.js.diff +++ b/testdata/baselines/reference/submodule/conformance/mixinAccessors3.js.diff @@ -7,22 +7,4 @@ -"use strict"; function mixin(superclass) { return class extends superclass { - get name() { -@@= skipped -24, +23 lines =@@ - new (...args: any[]): {}; - }>(superclass: T): { - new (...args: any[]): { -- get name(): string; -+ readonly name: string; - }; - } & T; - declare class BaseClass { -@@= skipped -8, +8 lines =@@ - } - declare const MyClass_base: { - new (...args: any[]): { -- get name(): string; -+ readonly name: string; - }; - } & typeof BaseClass; - declare class MyClass extends MyClass_base { \ No newline at end of file + get name() { \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/mixinAccessors4.errors.txt b/testdata/baselines/reference/submodule/conformance/mixinAccessors4.errors.txt deleted file mode 100644 index 943b39532c..0000000000 --- a/testdata/baselines/reference/submodule/conformance/mixinAccessors4.errors.txt +++ /dev/null @@ -1,29 +0,0 @@ -mixinAccessors4.ts(19,7): error TS2611: 'myName' is defined as a property in class 'Mixin.B & A', but is overridden here in 'C' as an accessor. - - -==== mixinAccessors4.ts (1 errors) ==== - // https://github.com/microsoft/TypeScript/issues/44938 - - class A { - constructor(...args: any[]) {} - get myName(): string { - return "A"; - } - } - - function Mixin(Super: T) { - return class B extends Super { - get myName(): string { - return "B"; - } - }; - } - - class C extends Mixin(A) { - get myName(): string { - ~~~~~~ -!!! error TS2611: 'myName' is defined as a property in class 'Mixin.B & A', but is overridden here in 'C' as an accessor. - return "C"; - } - } - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/mixinAccessors4.errors.txt.diff b/testdata/baselines/reference/submodule/conformance/mixinAccessors4.errors.txt.diff deleted file mode 100644 index 713d5f91aa..0000000000 --- a/testdata/baselines/reference/submodule/conformance/mixinAccessors4.errors.txt.diff +++ /dev/null @@ -1,33 +0,0 @@ ---- old.mixinAccessors4.errors.txt -+++ new.mixinAccessors4.errors.txt -@@= skipped -0, +0 lines =@@ -- -+mixinAccessors4.ts(19,7): error TS2611: 'myName' is defined as a property in class 'Mixin.B & A', but is overridden here in 'C' as an accessor. -+ -+ -+==== mixinAccessors4.ts (1 errors) ==== -+ // https://github.com/microsoft/TypeScript/issues/44938 -+ -+ class A { -+ constructor(...args: any[]) {} -+ get myName(): string { -+ return "A"; -+ } -+ } -+ -+ function Mixin(Super: T) { -+ return class B extends Super { -+ get myName(): string { -+ return "B"; -+ } -+ }; -+ } -+ -+ class C extends Mixin(A) { -+ get myName(): string { -+ ~~~~~~ -+!!! error TS2611: 'myName' is defined as a property in class 'Mixin.B & A', but is overridden here in 'C' as an accessor. -+ return "C"; -+ } -+ } -+ \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/mixinAccessors4.js b/testdata/baselines/reference/submodule/conformance/mixinAccessors4.js index b5851f7dfc..9c8660bd82 100644 --- a/testdata/baselines/reference/submodule/conformance/mixinAccessors4.js +++ b/testdata/baselines/reference/submodule/conformance/mixinAccessors4.js @@ -54,12 +54,12 @@ declare class A { } declare function Mixin(Super: T): { new (...args: any[]): { - readonly myName: string; + get myName(): string; }; } & T; declare const C_base: { new (...args: any[]): { - readonly myName: string; + get myName(): string; }; } & typeof A; declare class C extends C_base { diff --git a/testdata/baselines/reference/submodule/conformance/mixinAccessors4.js.diff b/testdata/baselines/reference/submodule/conformance/mixinAccessors4.js.diff index 686537db8b..90ad28b02f 100644 --- a/testdata/baselines/reference/submodule/conformance/mixinAccessors4.js.diff +++ b/testdata/baselines/reference/submodule/conformance/mixinAccessors4.js.diff @@ -7,19 +7,4 @@ -"use strict"; // https://github.com/microsoft/TypeScript/issues/44938 class A { - constructor(...args) { } -@@= skipped -29, +28 lines =@@ - } - declare function Mixin(Super: T): { - new (...args: any[]): { -- get myName(): string; -+ readonly myName: string; - }; - } & T; - declare const C_base: { - new (...args: any[]): { -- get myName(): string; -+ readonly myName: string; - }; - } & typeof A; - declare class C extends C_base { \ No newline at end of file + constructor(...args) { } \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/mixinAccessors5.errors.txt b/testdata/baselines/reference/submodule/conformance/mixinAccessors5.errors.txt deleted file mode 100644 index 0a40860b18..0000000000 --- a/testdata/baselines/reference/submodule/conformance/mixinAccessors5.errors.txt +++ /dev/null @@ -1,29 +0,0 @@ -mixinAccessors5.ts(21,16): error TS2611: 'inCompendium' is defined as a property in class 'GetterA & GetterB', but is overridden here in 'TestB' as an accessor. - - -==== mixinAccessors5.ts (1 errors) ==== - // https://github.com/microsoft/TypeScript/issues/61967 - - declare function basicMixin( - t: T, - u: U, - ): T & U; - - declare class GetterA { - constructor(...args: any[]); - - get inCompendium(): boolean; - } - - declare class GetterB { - constructor(...args: any[]); - - get inCompendium(): boolean; - } - - declare class TestB extends basicMixin(GetterA, GetterB) { - override get inCompendium(): boolean; - ~~~~~~~~~~~~ -!!! error TS2611: 'inCompendium' is defined as a property in class 'GetterA & GetterB', but is overridden here in 'TestB' as an accessor. - } - \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/mixinAccessors5.errors.txt.diff b/testdata/baselines/reference/submodule/conformance/mixinAccessors5.errors.txt.diff deleted file mode 100644 index b50fb4e676..0000000000 --- a/testdata/baselines/reference/submodule/conformance/mixinAccessors5.errors.txt.diff +++ /dev/null @@ -1,33 +0,0 @@ ---- old.mixinAccessors5.errors.txt -+++ new.mixinAccessors5.errors.txt -@@= skipped -0, +0 lines =@@ -- -+mixinAccessors5.ts(21,16): error TS2611: 'inCompendium' is defined as a property in class 'GetterA & GetterB', but is overridden here in 'TestB' as an accessor. -+ -+ -+==== mixinAccessors5.ts (1 errors) ==== -+ // https://github.com/microsoft/TypeScript/issues/61967 -+ -+ declare function basicMixin( -+ t: T, -+ u: U, -+ ): T & U; -+ -+ declare class GetterA { -+ constructor(...args: any[]); -+ -+ get inCompendium(): boolean; -+ } -+ -+ declare class GetterB { -+ constructor(...args: any[]); -+ -+ get inCompendium(): boolean; -+ } -+ -+ declare class TestB extends basicMixin(GetterA, GetterB) { -+ override get inCompendium(): boolean; -+ ~~~~~~~~~~~~ -+!!! error TS2611: 'inCompendium' is defined as a property in class 'GetterA & GetterB', but is overridden here in 'TestB' as an accessor. -+ } -+ \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.errors.txt b/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.errors.txt index a352e2b340..06b774dcbf 100644 --- a/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.errors.txt +++ b/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.errors.txt @@ -1,6 +1,6 @@ -nullishCoalescingOperator5.ts(6,6): error TS5076: '||' and '??' operations cannot be mixed without parentheses. +nullishCoalescingOperator5.ts(6,1): error TS5076: '??' and '||' operations cannot be mixed without parentheses. nullishCoalescingOperator5.ts(9,1): error TS5076: '||' and '??' operations cannot be mixed without parentheses. -nullishCoalescingOperator5.ts(12,6): error TS5076: '&&' and '??' operations cannot be mixed without parentheses. +nullishCoalescingOperator5.ts(12,6): error TS5076: '??' and '&&' operations cannot be mixed without parentheses. nullishCoalescingOperator5.ts(15,1): error TS5076: '&&' and '??' operations cannot be mixed without parentheses. @@ -11,8 +11,8 @@ nullishCoalescingOperator5.ts(15,1): error TS5076: '&&' and '??' operations cann // should be a syntax error a ?? b || c; - ~~~~~~ -!!! error TS5076: '||' and '??' operations cannot be mixed without parentheses. + ~~~~~~ +!!! error TS5076: '??' and '||' operations cannot be mixed without parentheses. // should be a syntax error a || b ?? c; @@ -22,7 +22,7 @@ nullishCoalescingOperator5.ts(15,1): error TS5076: '&&' and '??' operations cann // should be a syntax error a ?? b && c; ~~~~~~ -!!! error TS5076: '&&' and '??' operations cannot be mixed without parentheses. +!!! error TS5076: '??' and '&&' operations cannot be mixed without parentheses. // should be a syntax error a && b ?? c; diff --git a/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.errors.txt.diff b/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.errors.txt.diff deleted file mode 100644 index 27b8e320f9..0000000000 --- a/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.errors.txt.diff +++ /dev/null @@ -1,31 +0,0 @@ ---- old.nullishCoalescingOperator5.errors.txt -+++ new.nullishCoalescingOperator5.errors.txt -@@= skipped -0, +0 lines =@@ --nullishCoalescingOperator5.ts(6,1): error TS5076: '??' and '||' operations cannot be mixed without parentheses. -+nullishCoalescingOperator5.ts(6,6): error TS5076: '||' and '??' operations cannot be mixed without parentheses. - nullishCoalescingOperator5.ts(9,1): error TS5076: '||' and '??' operations cannot be mixed without parentheses. --nullishCoalescingOperator5.ts(12,6): error TS5076: '??' and '&&' operations cannot be mixed without parentheses. -+nullishCoalescingOperator5.ts(12,6): error TS5076: '&&' and '??' operations cannot be mixed without parentheses. - nullishCoalescingOperator5.ts(15,1): error TS5076: '&&' and '??' operations cannot be mixed without parentheses. - - -@@= skipped -10, +10 lines =@@ - - // should be a syntax error - a ?? b || c; -- ~~~~~~ --!!! error TS5076: '??' and '||' operations cannot be mixed without parentheses. -+ ~~~~~~ -+!!! error TS5076: '||' and '??' operations cannot be mixed without parentheses. - - // should be a syntax error - a || b ?? c; -@@= skipped -11, +11 lines =@@ - // should be a syntax error - a ?? b && c; - ~~~~~~ --!!! error TS5076: '??' and '&&' operations cannot be mixed without parentheses. -+!!! error TS5076: '&&' and '??' operations cannot be mixed without parentheses. - - // should be a syntax error - a && b ?? c; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.js b/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.js index 49e49d535b..2fd55a5f61 100644 --- a/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.js +++ b/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.js @@ -45,7 +45,7 @@ a && (b ?? c); //// [nullishCoalescingOperator5.js] var _a, _b, _c, _d; // should be a syntax error -a !== null && a !== void 0 ? a : b || c; +(a !== null && a !== void 0 ? a : b) || c; // should be a syntax error (_a = a || b) !== null && _a !== void 0 ? _a : c; // should be a syntax error diff --git a/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.js.diff b/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.js.diff index d3291c48fc..56762afba0 100644 --- a/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.js.diff +++ b/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.js.diff @@ -7,8 +7,4 @@ -"use strict"; var _a, _b, _c, _d; // should be a syntax error --(a !== null && a !== void 0 ? a : b) || c; -+a !== null && a !== void 0 ? a : b || c; - // should be a syntax error - (_a = a || b) !== null && _a !== void 0 ? _a : c; - // should be a syntax error \ No newline at end of file + (a !== null && a !== void 0 ? a : b) || c; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.types b/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.types index f92dafbe64..eb55440d56 100644 --- a/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.types +++ b/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.types @@ -13,8 +13,8 @@ declare const c: string | undefined // should be a syntax error a ?? b || c; >a ?? b || c : string | undefined +>a ?? b : string | undefined >a : string | undefined ->b || c : string | undefined >b : string | undefined >c : string | undefined diff --git a/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.types.diff b/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.types.diff deleted file mode 100644 index 3c14581c38..0000000000 --- a/testdata/baselines/reference/submodule/conformance/nullishCoalescingOperator5.types.diff +++ /dev/null @@ -1,11 +0,0 @@ ---- old.nullishCoalescingOperator5.types -+++ new.nullishCoalescingOperator5.types -@@= skipped -12, +12 lines =@@ - // should be a syntax error - a ?? b || c; - >a ?? b || c : string | undefined -->a ?? b : string | undefined - >a : string | undefined -+>b || c : string | undefined - >b : string | undefined - >c : string | undefined diff --git a/testdata/baselines/reference/submodule/conformance/plainJSGrammarErrors.errors.txt b/testdata/baselines/reference/submodule/conformance/plainJSGrammarErrors.errors.txt index 40731faa29..d4de4272f9 100644 --- a/testdata/baselines/reference/submodule/conformance/plainJSGrammarErrors.errors.txt +++ b/testdata/baselines/reference/submodule/conformance/plainJSGrammarErrors.errors.txt @@ -58,7 +58,7 @@ plainJSGrammarErrors.js(92,33): error TS2566: A rest element cannot have a prope plainJSGrammarErrors.js(93,42): error TS1186: A rest element cannot have an initializer. plainJSGrammarErrors.js(96,4): error TS1123: Variable declaration list cannot be empty. plainJSGrammarErrors.js(97,9): error TS5076: '||' and '??' operations cannot be mixed without parentheses. -plainJSGrammarErrors.js(98,14): error TS5076: '||' and '??' operations cannot be mixed without parentheses. +plainJSGrammarErrors.js(98,9): error TS5076: '??' and '||' operations cannot be mixed without parentheses. plainJSGrammarErrors.js(100,3): error TS1200: Line terminator not permitted before arrow. plainJSGrammarErrors.js(102,4): error TS1358: Tagged template expressions are not permitted in an optional chain. plainJSGrammarErrors.js(104,6): error TS1171: A comma expression is not allowed in a computed property name. @@ -320,8 +320,8 @@ plainJSGrammarErrors.js(205,36): error TS1325: Argument of dynamic import cannot ~~~~~~ !!! error TS5076: '||' and '??' operations cannot be mixed without parentheses. var x = 2 ?? 3 || 4 - ~~~~~~ -!!! error TS5076: '||' and '??' operations cannot be mixed without parentheses. + ~~~~~~ +!!! error TS5076: '??' and '||' operations cannot be mixed without parentheses. const arr = x => x + 1 ~~ diff --git a/testdata/baselines/reference/submodule/conformance/plainJSGrammarErrors.js b/testdata/baselines/reference/submodule/conformance/plainJSGrammarErrors.js index eccd22d9e6..3738de6fa2 100644 --- a/testdata/baselines/reference/submodule/conformance/plainJSGrammarErrors.js +++ b/testdata/baselines/reference/submodule/conformance/plainJSGrammarErrors.js @@ -303,8 +303,8 @@ const { e: eep, m: em, ...rest: noRestAllowed } = doom; const { e: erp, m: erm, ...noInitialiser = true } = doom; // left-over parsing var ; -var x = (1 || 2) ?? 3; -var x = 2 ?? (3 || 4); +var x = 1 || 2 ?? 3; +var x = 2 ?? 3 || 4; const arr = x => x + 1; var a = [1, 2]; a `length`; diff --git a/testdata/baselines/reference/submodule/conformance/plainJSGrammarErrors.js.diff b/testdata/baselines/reference/submodule/conformance/plainJSGrammarErrors.js.diff index ff2c0bd52b..db62b31259 100644 --- a/testdata/baselines/reference/submodule/conformance/plainJSGrammarErrors.js.diff +++ b/testdata/baselines/reference/submodule/conformance/plainJSGrammarErrors.js.diff @@ -38,15 +38,7 @@ export import 'fs'; export { C }; function nestedExports() { -@@= skipped -30, +30 lines =@@ - const { e: erp, m: erm, ...noInitialiser = true } = doom; - // left-over parsing - var ; --var x = 1 || 2 ?? 3; --var x = 2 ?? 3 || 4; -+var x = (1 || 2) ?? 3; -+var x = 2 ?? (3 || 4); - const arr = x => x + 1; +@@= skipped -36, +36 lines =@@ var a = [1, 2]; a `length`; const o = { diff --git a/testdata/baselines/reference/submodule/conformance/plainJSGrammarErrors.types b/testdata/baselines/reference/submodule/conformance/plainJSGrammarErrors.types index 5e2cbda34a..135597fd49 100644 --- a/testdata/baselines/reference/submodule/conformance/plainJSGrammarErrors.types +++ b/testdata/baselines/reference/submodule/conformance/plainJSGrammarErrors.types @@ -278,8 +278,8 @@ var x = 1 || 2 ?? 3 var x = 2 ?? 3 || 4 >x : number >2 ?? 3 || 4 : 2 | 3 | 4 +>2 ?? 3 : 2 | 3 >2 : 2 ->3 || 4 : 3 | 4 >3 : 3 >4 : 4 diff --git a/testdata/baselines/reference/submodule/conformance/usingDeclarations.16.errors.txt b/testdata/baselines/reference/submodule/conformance/usingDeclarations.16.errors.txt new file mode 100644 index 0000000000..90514ada95 --- /dev/null +++ b/testdata/baselines/reference/submodule/conformance/usingDeclarations.16.errors.txt @@ -0,0 +1,24 @@ +usingDeclarations.16.ts(2,5): error TS1545: 'using' declarations are not allowed in ambient contexts. +usingDeclarations.16.ts(3,5): error TS1545: 'using' declarations are not allowed in ambient contexts. +usingDeclarations.16.ts(6,5): error TS1545: 'using' declarations are not allowed in ambient contexts. +usingDeclarations.16.ts(7,5): error TS1545: 'using' declarations are not allowed in ambient contexts. + + +==== usingDeclarations.16.ts (4 errors) ==== + declare namespace N { + using x: { [Symbol.dispose](): void }; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS1545: 'using' declarations are not allowed in ambient contexts. + using y: null; + ~~~~~~~~~~~~~ +!!! error TS1545: 'using' declarations are not allowed in ambient contexts. + } + declare module 'M' { + using x: { [Symbol.dispose](): void }; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS1545: 'using' declarations are not allowed in ambient contexts. + using y: null; + ~~~~~~~~~~~~~ +!!! error TS1545: 'using' declarations are not allowed in ambient contexts. + } + \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/conformance/usingDeclarations.16.errors.txt.diff b/testdata/baselines/reference/submodule/conformance/usingDeclarations.16.errors.txt.diff deleted file mode 100644 index 71b566aa2b..0000000000 --- a/testdata/baselines/reference/submodule/conformance/usingDeclarations.16.errors.txt.diff +++ /dev/null @@ -1,28 +0,0 @@ ---- old.usingDeclarations.16.errors.txt -+++ new.usingDeclarations.16.errors.txt -@@= skipped -0, +0 lines =@@ --usingDeclarations.16.ts(2,5): error TS1545: 'using' declarations are not allowed in ambient contexts. --usingDeclarations.16.ts(3,5): error TS1545: 'using' declarations are not allowed in ambient contexts. --usingDeclarations.16.ts(6,5): error TS1545: 'using' declarations are not allowed in ambient contexts. --usingDeclarations.16.ts(7,5): error TS1545: 'using' declarations are not allowed in ambient contexts. -- -- --==== usingDeclarations.16.ts (4 errors) ==== -- declare namespace N { -- using x: { [Symbol.dispose](): void }; -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --!!! error TS1545: 'using' declarations are not allowed in ambient contexts. -- using y: null; -- ~~~~~~~~~~~~~ --!!! error TS1545: 'using' declarations are not allowed in ambient contexts. -- } -- declare module 'M' { -- using x: { [Symbol.dispose](): void }; -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --!!! error TS1545: 'using' declarations are not allowed in ambient contexts. -- using y: null; -- ~~~~~~~~~~~~~ --!!! error TS1545: 'using' declarations are not allowed in ambient contexts. -- } -- -+ \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameAlias3.baseline.jsonc b/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameAlias3.baseline.jsonc index af74bffd51..ca8a01e4ff 100644 --- a/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameAlias3.baseline.jsonc +++ b/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameAlias3.baseline.jsonc @@ -2,12 +2,12 @@ // === /renameAlias3.ts === // module SomeModule { export class /*RENAME*/[|SomeClassRENAME|] { } } // import M = SomeModule; -// import C = M.SomeClass; +// import C = M.[|SomeClassRENAME|]; // === findRenameLocations === // === /renameAlias3.ts === -// module SomeModule { export class SomeClass { } } +// module SomeModule { export class [|SomeClassRENAME|] { } } // import M = SomeModule; // import C = M./*RENAME*/[|SomeClassRENAME|]; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameAlias3.baseline.jsonc.diff b/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameAlias3.baseline.jsonc.diff deleted file mode 100644 index 24d0d63d58..0000000000 --- a/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameAlias3.baseline.jsonc.diff +++ /dev/null @@ -1,17 +0,0 @@ ---- old.renameAlias3.baseline.jsonc -+++ new.renameAlias3.baseline.jsonc -@@= skipped -1, +1 lines =@@ - // === /renameAlias3.ts === - // module SomeModule { export class /*RENAME*/[|SomeClassRENAME|] { } } - // import M = SomeModule; --// import C = M.[|SomeClassRENAME|]; -+// import C = M.SomeClass; - - - - // === findRenameLocations === - // === /renameAlias3.ts === --// module SomeModule { export class [|SomeClassRENAME|] { } } -+// module SomeModule { export class SomeClass { } } - // import M = SomeModule; - // import C = M./*RENAME*/[|SomeClassRENAME|]; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameAliasExternalModule3.baseline.jsonc b/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameAliasExternalModule3.baseline.jsonc index c9f18c5c49..8b0ec2b3ce 100644 --- a/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameAliasExternalModule3.baseline.jsonc +++ b/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameAliasExternalModule3.baseline.jsonc @@ -3,9 +3,17 @@ // module SomeModule { export class /*RENAME*/[|SomeClassRENAME|] { } } // export = SomeModule; +// === /b.ts === +// import M = require("./a"); +// import C = M.[|SomeClassRENAME|]; + // === findRenameLocations === +// === /a.ts === +// module SomeModule { export class [|SomeClassRENAME|] { } } +// export = SomeModule; + // === /b.ts === // import M = require("./a"); // import C = M./*RENAME*/[|SomeClassRENAME|]; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameAliasExternalModule3.baseline.jsonc.diff b/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameAliasExternalModule3.baseline.jsonc.diff deleted file mode 100644 index b3dc143222..0000000000 --- a/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameAliasExternalModule3.baseline.jsonc.diff +++ /dev/null @@ -1,20 +0,0 @@ ---- old.renameAliasExternalModule3.baseline.jsonc -+++ new.renameAliasExternalModule3.baseline.jsonc -@@= skipped -2, +2 lines =@@ - // module SomeModule { export class /*RENAME*/[|SomeClassRENAME|] { } } - // export = SomeModule; - --// === /b.ts === --// import M = require("./a"); --// import C = M.[|SomeClassRENAME|]; -- - - - // === findRenameLocations === --// === /a.ts === --// module SomeModule { export class [|SomeClassRENAME|] { } } --// export = SomeModule; -- - // === /b.ts === - // import M = require("./a"); - // import C = M./*RENAME*/[|SomeClassRENAME|]; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameImportSpecifierPropertyName.baseline.jsonc b/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameImportSpecifierPropertyName.baseline.jsonc index 0f25847ed6..91bfb125b4 100644 --- a/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameImportSpecifierPropertyName.baseline.jsonc +++ b/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameImportSpecifierPropertyName.baseline.jsonc @@ -1,3 +1,6 @@ // === findRenameLocations === // === /canada.ts === -// export interface /*RENAME*/[|GingerRENAME|] {} \ No newline at end of file +// export interface /*RENAME*/[|GingerRENAME|] {} + +// === /dry.ts === +// import { [|GingerRENAME|] as Ale } from './canada'; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameImportSpecifierPropertyName.baseline.jsonc.diff b/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameImportSpecifierPropertyName.baseline.jsonc.diff deleted file mode 100644 index 8cd0cedcf3..0000000000 --- a/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameImportSpecifierPropertyName.baseline.jsonc.diff +++ /dev/null @@ -1,9 +0,0 @@ ---- old.renameImportSpecifierPropertyName.baseline.jsonc -+++ new.renameImportSpecifierPropertyName.baseline.jsonc -@@= skipped -0, +0 lines =@@ - // === findRenameLocations === - // === /canada.ts === - // export interface /*RENAME*/[|GingerRENAME|] {} -- --// === /dry.ts === --// import { [|GingerRENAME|] as Ale } from './canada'; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameNamespace.baseline.jsonc b/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameNamespace.baseline.jsonc index 1a1735ba7a..0ccb3ca35f 100644 --- a/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameNamespace.baseline.jsonc +++ b/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameNamespace.baseline.jsonc @@ -6,4 +6,4 @@ // } // } // -// const a: [|NSRENAME|].E = NS.E.A; \ No newline at end of file +// const a: [|NSRENAME|].E = [|NSRENAME|].E.A; \ No newline at end of file diff --git a/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameNamespace.baseline.jsonc.diff b/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameNamespace.baseline.jsonc.diff deleted file mode 100644 index 220774abf8..0000000000 --- a/testdata/baselines/reference/submodule/fourslash/findRenameLocations/renameNamespace.baseline.jsonc.diff +++ /dev/null @@ -1,8 +0,0 @@ ---- old.renameNamespace.baseline.jsonc -+++ new.renameNamespace.baseline.jsonc -@@= skipped -5, +5 lines =@@ - // } - // } - // --// const a: [|NSRENAME|].E = [|NSRENAME|].E.A; -+// const a: [|NSRENAME|].E = NS.E.A; \ No newline at end of file diff --git a/testdata/baselines/reference/submoduleAccepted/conformance/plainJSGrammarErrors.errors.txt.diff b/testdata/baselines/reference/submoduleAccepted/conformance/plainJSGrammarErrors.errors.txt.diff index cd52c1ca63..249a843d77 100644 --- a/testdata/baselines/reference/submoduleAccepted/conformance/plainJSGrammarErrors.errors.txt.diff +++ b/testdata/baselines/reference/submoduleAccepted/conformance/plainJSGrammarErrors.errors.txt.diff @@ -18,16 +18,7 @@ plainJSGrammarErrors.js(64,1): error TS1042: 'async' modifier cannot be used here. plainJSGrammarErrors.js(65,1): error TS1042: 'async' modifier cannot be used here. plainJSGrammarErrors.js(66,1): error TS1042: 'async' modifier cannot be used here. -@@= skipped -21, +20 lines =@@ - plainJSGrammarErrors.js(93,42): error TS1186: A rest element cannot have an initializer. - plainJSGrammarErrors.js(96,4): error TS1123: Variable declaration list cannot be empty. - plainJSGrammarErrors.js(97,9): error TS5076: '||' and '??' operations cannot be mixed without parentheses. --plainJSGrammarErrors.js(98,9): error TS5076: '??' and '||' operations cannot be mixed without parentheses. -+plainJSGrammarErrors.js(98,14): error TS5076: '||' and '??' operations cannot be mixed without parentheses. - plainJSGrammarErrors.js(100,3): error TS1200: Line terminator not permitted before arrow. - plainJSGrammarErrors.js(102,4): error TS1358: Tagged template expressions are not permitted in an optional chain. - plainJSGrammarErrors.js(104,6): error TS1171: A comma expression is not allowed in a computed property name. -@@= skipped -43, +43 lines =@@ +@@= skipped -64, +63 lines =@@ plainJSGrammarErrors.js(205,36): error TS1325: Argument of dynamic import cannot be spread element. @@ -62,15 +53,4 @@ -!!! error TS8009: The 'async' modifier can only be used in TypeScript files. } async const cantAsyncConst = 2 - ~~~~~ -@@= skipped -78, +76 lines =@@ - ~~~~~~ - !!! error TS5076: '||' and '??' operations cannot be mixed without parentheses. - var x = 2 ?? 3 || 4 -- ~~~~~~ --!!! error TS5076: '??' and '||' operations cannot be mixed without parentheses. -+ ~~~~~~ -+!!! error TS5076: '||' and '??' operations cannot be mixed without parentheses. - const arr = x - => x + 1 - ~~ \ No newline at end of file + ~~~~~ \ No newline at end of file diff --git a/testdata/baselines/reference/submoduleAccepted/conformance/plainJSGrammarErrors.types.diff b/testdata/baselines/reference/submoduleAccepted/conformance/plainJSGrammarErrors.types.diff index 19ae51b03e..3843c64aaf 100644 --- a/testdata/baselines/reference/submoduleAccepted/conformance/plainJSGrammarErrors.types.diff +++ b/testdata/baselines/reference/submoduleAccepted/conformance/plainJSGrammarErrors.types.diff @@ -9,17 +9,7 @@ export { staticParam } >staticParam : any -@@= skipped -97, +97 lines =@@ - var x = 2 ?? 3 || 4 - >x : number - >2 ?? 3 || 4 : 2 | 3 | 4 -->2 ?? 3 : 2 | 3 - >2 : 2 -+>3 || 4 : 3 | 4 - >3 : 3 - >4 : 4 - -@@= skipped -194, +194 lines =@@ +@@= skipped -291, +291 lines =@@ >b : any switch (b) { diff --git a/testdata/baselines/reference/tsc/commandLine/does-not-add-color-when-NO_COLOR-is-set.js b/testdata/baselines/reference/tsc/commandLine/does-not-add-color-when-NO_COLOR-is-set.js index 685d8ed5b8..b349e1df0e 100644 --- a/testdata/baselines/reference/tsc/commandLine/does-not-add-color-when-NO_COLOR-is-set.js +++ b/testdata/baselines/reference/tsc/commandLine/does-not-add-color-when-NO_COLOR-is-set.js @@ -117,7 +117,7 @@ default: false --jsx Specify what JSX code is generated. -one of: preserve, react-native, react, react-jsx, react-jsxdev +one of: preserve, react-native, react-jsx, react-jsxdev, react default: undefined --outFile diff --git a/testdata/baselines/reference/tsc/commandLine/help.js b/testdata/baselines/reference/tsc/commandLine/help.js index 135bbe9f96..1eb6ad1811 100644 --- a/testdata/baselines/reference/tsc/commandLine/help.js +++ b/testdata/baselines/reference/tsc/commandLine/help.js @@ -116,7 +116,7 @@ default: false --jsx Specify what JSX code is generated. -one of: preserve, react-native, react, react-jsx, react-jsxdev +one of: preserve, react-native, react-jsx, react-jsxdev, react default: undefined --outFile diff --git a/testdata/baselines/reference/tsc/commandLine/show-help-with-ExitStatus.DiagnosticsPresent_OutputsSkipped-when-host-cannot-provide-terminal-width.js b/testdata/baselines/reference/tsc/commandLine/show-help-with-ExitStatus.DiagnosticsPresent_OutputsSkipped-when-host-cannot-provide-terminal-width.js index 2a6e7ccc53..244169b3bb 100644 --- a/testdata/baselines/reference/tsc/commandLine/show-help-with-ExitStatus.DiagnosticsPresent_OutputsSkipped-when-host-cannot-provide-terminal-width.js +++ b/testdata/baselines/reference/tsc/commandLine/show-help-with-ExitStatus.DiagnosticsPresent_OutputsSkipped-when-host-cannot-provide-terminal-width.js @@ -117,7 +117,7 @@ default: false --jsx Specify what JSX code is generated. -one of: preserve, react-native, react, react-jsx, react-jsxdev +one of: preserve, react-native, react-jsx, react-jsxdev, react default: undefined --outFile diff --git a/testdata/baselines/reference/tsc/commandLine/show-help-with-ExitStatus.DiagnosticsPresent_OutputsSkipped.js b/testdata/baselines/reference/tsc/commandLine/show-help-with-ExitStatus.DiagnosticsPresent_OutputsSkipped.js index 69340ddbae..86cc398b85 100644 --- a/testdata/baselines/reference/tsc/commandLine/show-help-with-ExitStatus.DiagnosticsPresent_OutputsSkipped.js +++ b/testdata/baselines/reference/tsc/commandLine/show-help-with-ExitStatus.DiagnosticsPresent_OutputsSkipped.js @@ -158,7 +158,7 @@ tsc: The TypeScript Compiler - Version FakeTSVersion  --jsx Specify what JSX code is generated. - one of: preserve, react-native, react, react-jsx, react-jsxdev + one of: preserve, react-native, react-jsx, react-jsxdev, react default: undefined diff --git a/testdata/baselines/reference/tscWatch/commandLine/Parse-watch-interval-option-without-tsconfig.json.js b/testdata/baselines/reference/tscWatch/commandLine/Parse-watch-interval-option-without-tsconfig.json.js index 0859e4f9f3..6a59db07d6 100644 --- a/testdata/baselines/reference/tscWatch/commandLine/Parse-watch-interval-option-without-tsconfig.json.js +++ b/testdata/baselines/reference/tscWatch/commandLine/Parse-watch-interval-option-without-tsconfig.json.js @@ -117,7 +117,7 @@ default: false --jsx Specify what JSX code is generated. -one of: preserve, react-native, react, react-jsx, react-jsxdev +one of: preserve, react-native, react-jsx, react-jsxdev, react default: undefined --outFile diff --git a/testdata/baselines/reference/tsoptions/commandLineParsing/parseCommandLine/Parse empty options of --jsx.js b/testdata/baselines/reference/tsoptions/commandLineParsing/parseCommandLine/Parse empty options of --jsx.js index e7a82f6c79..ad4d2b9d2a 100644 --- a/testdata/baselines/reference/tsoptions/commandLineParsing/parseCommandLine/Parse empty options of --jsx.js +++ b/testdata/baselines/reference/tsoptions/commandLineParsing/parseCommandLine/Parse empty options of --jsx.js @@ -9,4 +9,4 @@ FileNames:: Errors:: error TS6044: Compiler option 'jsx' expects an argument. -error TS6046: Argument for '--jsx' option must be: 'preserve', 'react-native', 'react', 'react-jsx', 'react-jsxdev'. +error TS6046: Argument for '--jsx' option must be: 'preserve', 'react-native', 'react-jsx', 'react-jsxdev', 'react'.